@a-company/paradigm 5.10.0 → 5.21.0

package/dist/chunk-VPPK3SY4.js

@@ -1,1136 +0,0 @@
-#!/usr/bin/env node
-import {
-  init_agent_loader,
-  loadAgentProfile,
-  loadAllAgentProfiles,
-  saveAgentProfile
-} from "./chunk-RJE5G7WO.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 (profile.benched) 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, reason) {
-  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;
-          if (reason) nom.reason = reason;
-          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 STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
-  const allNominations = loadNominations(rootDir, { agent: agentId });
-  const active = allNominations.filter(
-    (n) => n.engaged || Date.now() - new Date(n.timestamp).getTime() < STALE_THRESHOLD_MS
-  );
-  const engaged = active.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 STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
-  const allNominations = loadNominations(rootDir, { agent: agentId });
-  const nominations = allNominations.filter(
-    (n) => n.engaged || Date.now() - new Date(n.timestamp).getTime() < STALE_THRESHOLD_MS
-  );
-  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 getNeverlandMetrics(rootDir) {
-  const profiles = loadAllAgentProfiles(rootDir);
-  const agentMetrics = profiles.filter((p) => !p.benched).map((p) => {
-    const stats = getNominationStats(rootDir, p.id);
-    let notebookCount = 0;
-    try {
-      const nbDir = path4.join(os2.homedir(), ".paradigm", "notebooks", p.id);
-      if (fs4.existsSync(nbDir)) {
-        notebookCount = fs4.readdirSync(nbDir).filter((f) => f.endsWith(".yaml")).length;
-      }
-    } catch {
-    }
-    return {
-      id: p.id,
-      acceptRate: stats.acceptRate,
-      threshold: p.attention?.threshold ?? 0.5,
-      expertiseCount: (p.expertise || []).length,
-      notebookCount,
-      transferableCount: (p.transferable || []).length,
-      totalNominations: stats.total
-    };
-  });
-  const count = agentMetrics.length || 1;
-  const avgAcceptRate = agentMetrics.reduce((s, a) => s + a.acceptRate, 0) / count;
-  const avgThreshold = agentMetrics.reduce((s, a) => s + a.threshold, 0) / count;
-  const totalExpertise = agentMetrics.reduce((s, a) => s + a.expertiseCount, 0);
-  const totalNotebooks = agentMetrics.reduce((s, a) => s + a.notebookCount, 0);
-  const totalTransferable = agentMetrics.reduce((s, a) => s + a.transferableCount, 0);
-  const totalNominations = agentMetrics.reduce((s, a) => s + a.totalNominations, 0);
-  let healthStatus;
-  if (totalNominations < 10) {
-    healthStatus = "cold-start";
-  } else if (avgAcceptRate < 0.5) {
-    healthStatus = "accumulating";
-  } else if (avgAcceptRate < 0.7) {
-    healthStatus = "calibrating";
-  } else {
-    healthStatus = "mature";
-  }
-  return {
-    agents: agentMetrics,
-    aggregate: {
-      avgAcceptRate,
-      avgThreshold,
-      totalExpertise,
-      totalNotebooks,
-      totalTransferable
-    },
-    healthStatus
-  };
-}
-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 patternEntries = loadJournalEntries(agentId, { trigger: "pattern_discovered", limit: 100 });
-  const feedbackEntries = loadJournalEntries(agentId, { trigger: "human_feedback", limit: 100 });
-  const journal = [...patternEntries, ...feedbackEntries];
-  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,
-  getNeverlandMetrics,
-  forwardNominationsToRelay,
-  autoPromoteJournalEntries,
-  loadSurfacingConfig,
-  applySurfacingRules,
-  init_nomination_engine
-};