@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-RJE5G7WO.js

@@ -1,590 +0,0 @@
-#!/usr/bin/env node
-import {
-  __esm
-} from "./chunk-7N7GSU6K.js";
-
-// ../paradigm-mcp/src/types/agents.ts
-var DEFAULT_PERSONALITIES, DEFAULT_ATTENTION, DEFAULT_COLLABORATION;
-var init_agents = __esm({
-  "../paradigm-mcp/src/types/agents.ts"() {
-    "use strict";
-    DEFAULT_PERSONALITIES = {
-      architect: { style: "deliberate", risk: "conservative", verbosity: "detailed" },
-      builder: { style: "rapid", risk: "balanced", verbosity: "concise" },
-      tester: { style: "methodical", risk: "conservative", verbosity: "concise" },
-      reviewer: { style: "deliberate", risk: "conservative", verbosity: "detailed" },
-      security: { style: "methodical", risk: "conservative", verbosity: "detailed" },
-      documentor: { style: "methodical", risk: "conservative", verbosity: "concise" }
-    };
-    DEFAULT_ATTENTION = {
-      architect: { symbols: ["$*", "#*"], concepts: ["architecture", "design", "pattern", "refactor"], signals: [{ type: "flow-modified" }, { type: "compliance-violation" }], threshold: 0.5 },
-      builder: { paths: ["src/**", "lib/**", "packages/**"], signals: [{ type: "file-modified" }, { type: "error-encountered" }], threshold: 0.7 },
-      reviewer: { concepts: ["code quality", "bug", "smell", "convention"], signals: [{ type: "compliance-violation" }], threshold: 0.6 },
-      tester: { paths: ["**/*.test.*", "**/*.spec.*"], concepts: ["test", "coverage", "assertion"], signals: [{ type: "error-encountered" }, { type: "test-result" }], threshold: 0.5 },
-      security: { symbols: ["^*", "#*-auth", "#*-middleware"], paths: ["auth/**", "middleware/**", "guards/**"], concepts: ["permission", "JWT", "session", "RBAC", "XSS", "injection"], signals: [{ type: "gate-added" }, { type: "route-created" }, { type: "gate-checked" }, { type: "compliance-violation" }], threshold: 0.4 },
-      documentor: { paths: ["**/.purpose", "**/portal.yaml", ".paradigm/**"], concepts: ["purpose", "portal", "symbol", "documentation", "component", "gate", "flow"], signals: [{ type: "file-modified" }, { type: "compliance-violation" }, { type: "work-completed" }], threshold: 0.3 }
-    };
-    DEFAULT_COLLABORATION = {
-      architect: { stance: "lead", debate: { will_challenge: true, evidence_required: true, escalate_to_human: true } },
-      builder: { stance: "supportive", with: { architect: { stance: "supportive", can_contradict: false } } },
-      reviewer: { stance: "advisory", debate: { will_challenge: true, evidence_required: true, escalate_to_human: true } },
-      tester: { stance: "supportive", debate: { will_challenge: false, evidence_required: true, escalate_to_human: false } },
-      security: { stance: "advisory", with: { architect: { stance: "peer", can_contradict: true }, builder: { stance: "advisory", review_output: true } }, debate: { will_challenge: true, evidence_required: true, escalate_to_human: true } },
-      documentor: { stance: "supportive", with: { architect: { stance: "supportive" }, builder: { stance: "supportive" }, reviewer: { stance: "supportive" }, security: { stance: "supportive" } }, debate: { will_challenge: false, evidence_required: false, escalate_to_human: false } }
-    };
-  }
-});
-
-// ../paradigm-mcp/src/utils/agent-loader.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import * as crypto from "crypto";
-import * as yaml from "js-yaml";
-function loadProjectRoster(rootDir) {
-  const rosterPath = path.join(rootDir, ROSTER_FILE);
-  if (!fs.existsSync(rosterPath)) return null;
-  try {
-    const data = yaml.load(fs.readFileSync(rosterPath, "utf8"));
-    return data?.active ?? null;
-  } catch {
-    return null;
-  }
-}
-function isAgentActive(agentId, rootDir) {
-  const roster = loadProjectRoster(rootDir);
-  if (!roster) return true;
-  return roster.includes(agentId);
-}
-function saveProjectRoster(rootDir, active) {
-  const rosterPath = path.join(rootDir, ROSTER_FILE);
-  const dir = path.dirname(rosterPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const data = { version: "1.0", active: active.sort() };
-  fs.writeFileSync(rosterPath, yaml.dump(data, { lineWidth: -1, noRefs: true }), "utf8");
-}
-function listAllGlobalAgentIds() {
-  if (!fs.existsSync(GLOBAL_AGENTS_DIR)) return [];
-  try {
-    return fs.readdirSync(GLOBAL_AGENTS_DIR).filter((f) => f.endsWith(AGENT_EXT)).map((f) => f.replace(AGENT_EXT, ""));
-  } catch {
-    return [];
-  }
-}
-function loadAgentProfile(rootDir, agentId) {
-  const projectPath = path.join(rootDir, PROJECT_AGENTS_DIR, `${agentId}${AGENT_EXT}`);
-  if (fs.existsSync(projectPath)) {
-    try {
-      const content = fs.readFileSync(projectPath, "utf-8");
-      return yaml.load(content);
-    } catch {
-    }
-  }
-  const globalPath = path.join(GLOBAL_AGENTS_DIR, `${agentId}${AGENT_EXT}`);
-  if (fs.existsSync(globalPath)) {
-    try {
-      const content = fs.readFileSync(globalPath, "utf-8");
-      const globalProfile = yaml.load(content);
-      if (fs.existsSync(projectPath)) {
-        try {
-          const projectContent = fs.readFileSync(projectPath, "utf-8");
-          const projectProfile = yaml.load(projectContent);
-          return deepMergeProfiles(globalProfile, projectProfile);
-        } catch {
-        }
-      }
-      return globalProfile;
-    } catch {
-    }
-  }
-  return null;
-}
-function loadAllAgentProfiles(rootDir) {
-  const profiles = /* @__PURE__ */ new Map();
-  if (fs.existsSync(GLOBAL_AGENTS_DIR)) {
-    try {
-      const files = fs.readdirSync(GLOBAL_AGENTS_DIR).filter((f) => f.endsWith(AGENT_EXT));
-      for (const file of files) {
-        try {
-          const content = fs.readFileSync(path.join(GLOBAL_AGENTS_DIR, file), "utf-8");
-          const profile = yaml.load(content);
-          if (profile?.id) {
-            profiles.set(profile.id, profile);
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  const projectDir = path.join(rootDir, PROJECT_AGENTS_DIR);
-  if (fs.existsSync(projectDir)) {
-    try {
-      const files = fs.readdirSync(projectDir).filter((f) => f.endsWith(AGENT_EXT));
-      for (const file of files) {
-        try {
-          const content = fs.readFileSync(path.join(projectDir, file), "utf-8");
-          const projectProfile = yaml.load(content);
-          if (!projectProfile?.id) continue;
-          const existing = profiles.get(projectProfile.id);
-          if (existing) {
-            profiles.set(projectProfile.id, deepMergeProfiles(existing, projectProfile));
-          } else {
-            profiles.set(projectProfile.id, projectProfile);
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return Array.from(profiles.values());
-}
-function saveAgentProfile(agentId, profile, scope, rootDir) {
-  const dir = scope === "global" ? GLOBAL_AGENTS_DIR : path.join(rootDir || process.cwd(), PROJECT_AGENTS_DIR);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  const filePath = path.join(dir, `${agentId}${AGENT_EXT}`);
-  if (profile.permissions) {
-    profile.integrityHash = computeIntegrityHash(profile);
-  }
-  profile.updated = (/* @__PURE__ */ new Date()).toISOString();
-  const content = yaml.dump(profile, {
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  });
-  fs.writeFileSync(filePath, content, "utf-8");
-  return filePath;
-}
-function createAgentProfile(agentId, opts = {}) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const profile = {
-    id: agentId,
-    role: opts.role || `${agentId.charAt(0).toUpperCase() + agentId.slice(1)} agent`,
-    description: opts.description || `Persistent identity for the ${agentId} agent role`,
-    version: "1.0.0",
-    personality: DEFAULT_PERSONALITIES[agentId] || {
-      style: "balanced",
-      risk: "balanced",
-      verbosity: "concise"
-    },
-    expertise: [],
-    transferable: [],
-    contexts: {},
-    created: now,
-    updated: now
-  };
-  if (!DEFAULT_PERSONALITIES[agentId]) {
-    profile.personality = { style: "deliberate", risk: "balanced", verbosity: "concise" };
-  }
-  if (DEFAULT_ATTENTION[agentId]) {
-    profile.attention = { ...DEFAULT_ATTENTION[agentId] };
-  }
-  if (DEFAULT_COLLABORATION[agentId]) {
-    profile.collaboration = { ...DEFAULT_COLLABORATION[agentId] };
-  }
-  const scope = opts.scope || "global";
-  const filePath = saveAgentProfile(agentId, profile, scope, opts.rootDir);
-  return { profile, filePath };
-}
-function queryExpertise(rootDir, symbol) {
-  const profiles = loadAllAgentProfiles(rootDir);
-  const results = [];
-  for (const profile of profiles) {
-    const entry = (profile.expertise || []).find((e) => e.symbol === symbol);
-    if (entry) {
-      results.push({ agentId: profile.id, entry });
-    }
-  }
-  return results.sort((a, b) => b.entry.confidence - a.entry.confidence);
-}
-function updateExpertiseFromLore(rootDir, agentId, loreData) {
-  const profile = loadAgentProfile(rootDir, agentId);
-  if (!profile) return false;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const expertise = profile.expertise || [];
-  for (const symbol of loreData.symbols_touched) {
-    const existing = expertise.find((e) => e.symbol === symbol);
-    if (existing) {
-      existing.sessions++;
-      existing.lastTouch = now;
-      if (loreData.confidence != null) {
-        existing.confidence = (1 - EMA_ALPHA) * existing.confidence + EMA_ALPHA * loreData.confidence;
-      }
-    } else {
-      expertise.push({
-        symbol,
-        confidence: loreData.confidence ?? 0.5,
-        sessions: 1,
-        lastTouch: now
-      });
-    }
-  }
-  profile.expertise = expertise;
-  const projectName = detectProjectName(rootDir);
-  if (projectName) {
-    const ctx = profile.contexts[projectName] || { focus: [], sessionsInProject: 0 };
-    ctx.lastActive = now;
-    ctx.sessionsInProject = (ctx.sessionsInProject || 0) + 1;
-    profile.contexts[projectName] = ctx;
-  }
-  const projectPath = path.join(rootDir, PROJECT_AGENTS_DIR, `${agentId}${AGENT_EXT}`);
-  const scope = fs.existsSync(projectPath) ? "project" : "global";
-  saveAgentProfile(agentId, profile, scope, rootDir);
-  return true;
-}
-function updateExpertiseFromAssessment(rootDir, agentId, data) {
-  const profile = loadAgentProfile(rootDir, agentId);
-  if (!profile) return false;
-  const verdictScore = { correct: 1, partial: 0.5, incorrect: 0 };
-  const score = verdictScore[data.verdict];
-  for (const symbol of data.symbols_touched) {
-    const existing = (profile.expertise || []).find((e) => e.symbol === symbol);
-    if (existing) {
-      existing.confidence = (1 - EMA_ALPHA) * existing.confidence + EMA_ALPHA * score;
-    }
-  }
-  const projectPath = path.join(rootDir, PROJECT_AGENTS_DIR, `${agentId}${AGENT_EXT}`);
-  const scope = fs.existsSync(projectPath) ? "project" : "global";
-  saveAgentProfile(agentId, profile, scope, rootDir);
-  return true;
-}
-function mergeAgentProfileWithManifest(agentDef, profile, projectName) {
-  if (!profile) {
-    return {
-      personality: null,
-      topExpertise: [],
-      projectContext: null,
-      transferablePatterns: []
-    };
-  }
-  return {
-    personality: profile.personality || null,
-    topExpertise: (profile.expertise || []).sort((a, b) => b.confidence - a.confidence).slice(0, 10),
-    projectContext: profile.contexts?.[projectName] || null,
-    transferablePatterns: (profile.transferable || []).filter((p) => p.successRate >= 0.7).map((p) => ({ id: p.id, description: p.description, successRate: p.successRate }))
-  };
-}
-function buildProfileEnrichment(profile, relevantSymbols, notebookEntries, ambientContext, agentState) {
-  const parts = [];
-  if (profile.personality) {
-    const p = profile.personality;
-    parts.push(`## Agent Identity: ${profile.id}`);
-    parts.push(`**Style:** ${p.style} | **Risk:** ${p.risk} | **Verbosity:** ${p.verbosity}`);
-    parts.push("");
-  }
-  const relevant = (profile.expertise || []).filter((e) => relevantSymbols.length === 0 || relevantSymbols.includes(e.symbol)).sort((a, b) => b.confidence - a.confidence).slice(0, 8);
-  if (relevant.length > 0) {
-    parts.push("## Your Expertise on Relevant Symbols");
-    for (const e of relevant) {
-      parts.push(`- \`${e.symbol}\`: confidence ${e.confidence.toFixed(2)} (${e.sessions} sessions)`);
-    }
-    parts.push("");
-  }
-  const patterns = (profile.transferable || []).filter((p) => p.successRate >= 0.7);
-  if (patterns.length > 0) {
-    parts.push("## Transferable Patterns");
-    for (const p of patterns) {
-      const appliedCount = p.appliedIn?.length || 0;
-      parts.push(`- ${p.id}: ${(p.successRate * 100).toFixed(0)}% success (learned in ${p.learnedIn}${appliedCount > 0 ? `, applied in ${appliedCount} projects` : ""})`);
-    }
-    parts.push("");
-  }
-  if (notebookEntries && notebookEntries.length > 0) {
-    parts.push("## Relevant Notebook Entries");
-    for (const nb of notebookEntries.slice(0, 5)) {
-      parts.push(`### ${nb.context}`);
-      parts.push(`Concepts: ${nb.concepts.join(", ")}`);
-      parts.push("```");
-      const snippet = nb.snippet.length > 300 ? nb.snippet.slice(0, 300) + "..." : nb.snippet;
-      parts.push(snippet);
-      parts.push("```");
-      parts.push("");
-    }
-  }
-  if (agentState) {
-    parts.push("");
-    parts.push("## Your Recent Work on This Project");
-    if (agentState.lastSession) {
-      const ageMs = Date.now() - new Date(agentState.lastSession.date).getTime();
-      const ageHours = Math.floor(ageMs / (60 * 60 * 1e3));
-      const ageStr = ageHours < 24 ? `${ageHours}h ago` : `${Math.floor(ageHours / 24)}d ago`;
-      parts.push(`Last session (${ageStr}): ${agentState.lastSession.summary}`);
-    }
-    if (agentState.sessionsOnProject) {
-      parts.push(`Sessions on this project: ${agentState.sessionsOnProject}`);
-    }
-    if (agentState.pendingWork?.length) {
-      parts.push("**Pending from last session:**");
-      for (const item of agentState.pendingWork.slice(0, 5)) {
-        parts.push(`- ${item}`);
-      }
-    }
-    if (agentState.recentPatterns?.length) {
-      parts.push("**Project patterns you've learned:**");
-      for (const pattern of agentState.recentPatterns.slice(0, 5)) {
-        parts.push(`- ${pattern}`);
-      }
-    }
-    parts.push("");
-  }
-  if (profile.attention) {
-    const att = profile.attention;
-    const attParts = [];
-    if (att.symbols?.length) attParts.push(`Symbols: ${att.symbols.join(", ")}`);
-    if (att.paths?.length) attParts.push(`Paths: ${att.paths.join(", ")}`);
-    if (att.concepts?.length) attParts.push(`Concepts: ${att.concepts.join(", ")}`);
-    if (att.signals?.length) attParts.push(`Signals: ${att.signals.map((s) => s.type).join(", ")}`);
-    if (attParts.length > 0) {
-      parts.push("");
-      parts.push("### Attention");
-      parts.push(`Threshold: ${att.threshold ?? 0.6}`);
-      parts.push(attParts.join(" | "));
-    }
-  }
-  if (profile.collaboration) {
-    const collab = profile.collaboration;
-    parts.push("");
-    parts.push("### Collaboration");
-    parts.push(`Default stance: ${collab.stance || "supportive"}`);
-    if (collab.with) {
-      for (const [agent, rel] of Object.entries(collab.with)) {
-        const relParts = [`${agent}: ${rel.stance || "peer"}`];
-        if (rel.can_contradict) relParts.push("can contradict");
-        if (rel.review_output) relParts.push("reviews output");
-        parts.push(`- ${relParts.join(", ")}`);
-      }
-    }
-    if (collab.debate) {
-      const d = collab.debate;
-      const traits = [];
-      if (d.will_challenge) traits.push("challenges");
-      if (d.evidence_required) traits.push("evidence-based");
-      if (d.escalate_to_human) traits.push("escalates to human");
-      if (traits.length) parts.push(`Debate: ${traits.join(", ")}`);
-    }
-  }
-  if (profile.nomination) {
-    const nom = profile.nomination;
-    parts.push("");
-    parts.push("### Nomination");
-    if (nom.speak_when?.urgency?.length) {
-      parts.push(`Always speaks on: ${nom.speak_when.urgency.join(", ")}`);
-    }
-    if (nom.contribution_style) {
-      const style = [];
-      if (nom.contribution_style.brief_first) style.push("brief first");
-      if (nom.contribution_style.cite_sources) style.push("cites sources");
-      if (nom.contribution_style.offer_action) style.push("offers action");
-      if (style.length) parts.push(`Style: ${style.join(", ")}`);
-    }
-  }
-  if (ambientContext) {
-    if (ambientContext.recentDecisions?.length) {
-      parts.push("");
-      parts.push("## Recent Team Decisions");
-      for (const d of ambientContext.recentDecisions.slice(0, 5)) {
-        parts.push(`- **${d.title}**: ${d.decision.slice(0, 150)}${d.decision.length > 150 ? "..." : ""}`);
-      }
-    }
-    if (ambientContext.journalInsights?.length) {
-      parts.push("");
-      parts.push("## Transferable Insights");
-      for (const j of ambientContext.journalInsights.slice(0, 5)) {
-        parts.push(`- [${j.trigger}] ${j.insight.slice(0, 150)}${j.insight.length > 150 ? "..." : ""}`);
-      }
-    }
-    if (ambientContext.pendingNominations?.length) {
-      parts.push("");
-      parts.push("## Pending Nominations");
-      for (const n of ambientContext.pendingNominations.slice(0, 10)) {
-        parts.push(`- [${n.urgency}] ${n.brief}`);
-      }
-    }
-  }
-  return parts.join("\n");
-}
-async function syncExpertiseFromLore(rootDir, agentId, dryRun = false) {
-  const { loadLoreEntries } = await import("./lore-loader-7NO6N6FT.js");
-  const entries = await loadLoreEntries(rootDir, { limit: 500 });
-  let entriesProcessed = 0;
-  let symbolsUpdated = /* @__PURE__ */ new Set();
-  const profile = loadAgentProfile(rootDir, agentId) || createAgentProfile(agentId, { rootDir }).profile;
-  const expertise = profile.expertise || [];
-  for (const entry of entries) {
-    if (!entry.symbols_touched || entry.symbols_touched.length === 0) continue;
-    entriesProcessed++;
-    for (const symbol of entry.symbols_touched) {
-      symbolsUpdated.add(symbol);
-      const existing = expertise.find((e) => e.symbol === symbol);
-      if (existing) {
-        existing.sessions++;
-        existing.lastTouch = entry.timestamp;
-        if (entry.confidence != null) {
-          existing.confidence = (1 - EMA_ALPHA) * existing.confidence + EMA_ALPHA * entry.confidence;
-        }
-      } else {
-        expertise.push({
-          symbol,
-          confidence: entry.confidence ?? 0.5,
-          sessions: 1,
-          lastTouch: entry.timestamp
-        });
-      }
-    }
-  }
-  profile.expertise = expertise;
-  if (!dryRun) {
-    const projectPath = path.join(rootDir, PROJECT_AGENTS_DIR, `${agentId}${AGENT_EXT}`);
-    const scope = fs.existsSync(projectPath) ? "project" : "global";
-    saveAgentProfile(agentId, profile, scope, rootDir);
-  }
-  return { entriesProcessed, symbolsUpdated: symbolsUpdated.size };
-}
-function checkPathPermission(profile, filePath, mode) {
-  if (!profile.permissions?.paths) {
-    return { allowed: true };
-  }
-  const { read, write, deny } = profile.permissions.paths;
-  if (deny && deny.length > 0) {
-    for (const pattern of deny) {
-      if (matchGlob(pattern, filePath)) {
-        return { allowed: false, reason: `Path denied by pattern: ${pattern}` };
-      }
-    }
-  }
-  const allowPatterns = mode === "read" ? read : write;
-  if (allowPatterns && allowPatterns.length > 0) {
-    for (const pattern of allowPatterns) {
-      if (matchGlob(pattern, filePath)) {
-        return { allowed: true };
-      }
-    }
-    return { allowed: false, reason: `No ${mode} pattern matches: ${filePath}` };
-  }
-  return { allowed: true };
-}
-function checkToolPermission(profile, toolName) {
-  if (!profile.permissions?.tools) {
-    return { allowed: true };
-  }
-  const { allow, deny } = profile.permissions.tools;
-  if (deny && deny.length > 0) {
-    for (const pattern of deny) {
-      if (matchGlob(pattern, toolName)) {
-        return { allowed: false, reason: `Tool denied by pattern: ${pattern}` };
-      }
-    }
-  }
-  if (allow && allow.length > 0) {
-    for (const pattern of allow) {
-      if (matchGlob(pattern, toolName)) {
-        return { allowed: true };
-      }
-    }
-    return { allowed: false, reason: `Tool not in allow list: ${toolName}` };
-  }
-  return { allowed: true };
-}
-function computeIntegrityHash(profile) {
-  const payload = JSON.stringify({
-    id: profile.id,
-    role: profile.role,
-    permissions: profile.permissions || null
-  });
-  return crypto.createHash("sha256").update(payload).digest("hex");
-}
-function verifyIntegrity(profile) {
-  if (!profile.integrityHash) {
-    return { valid: true, reason: "No integrity hash stored (pre-4.0 profile)" };
-  }
-  const computed = computeIntegrityHash(profile);
-  if (computed === profile.integrityHash) {
-    return { valid: true };
-  }
-  return {
-    valid: false,
-    reason: "Integrity hash mismatch \u2014 profile may have been tampered with"
-  };
-}
-function matchGlob(pattern, value) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`).test(value);
-}
-function deepMergeProfiles(base, override) {
-  const merged = { ...base };
-  if (override.role) merged.role = override.role;
-  if (override.description) merged.description = override.description;
-  if (override.version) merged.version = override.version;
-  if (override.personality) {
-    merged.personality = { ...base.personality, ...override.personality };
-  }
-  if (override.expertise) {
-    const expertiseMap = new Map(base.expertise.map((e) => [e.symbol, e]));
-    for (const entry of override.expertise) {
-      expertiseMap.set(entry.symbol, entry);
-    }
-    merged.expertise = Array.from(expertiseMap.values());
-  }
-  if (override.transferable) {
-    const patternMap = new Map(base.transferable.map((p) => [p.id, p]));
-    for (const pattern of override.transferable) {
-      patternMap.set(pattern.id, pattern);
-    }
-    merged.transferable = Array.from(patternMap.values());
-  }
-  if (override.contexts) {
-    merged.contexts = { ...base.contexts };
-    for (const [project, ctx] of Object.entries(override.contexts)) {
-      merged.contexts[project] = { ...merged.contexts[project], ...ctx };
-    }
-  }
-  return merged;
-}
-function detectProjectName(rootDir) {
-  try {
-    const configPath = path.join(rootDir, ".paradigm", "config.yaml");
-    if (fs.existsSync(configPath)) {
-      const content = fs.readFileSync(configPath, "utf-8");
-      const config = yaml.load(content);
-      if (config?.project && typeof config.project === "string") return config.project;
-    }
-  } catch {
-  }
-  return path.basename(rootDir);
-}
-var GLOBAL_AGENTS_DIR, PROJECT_AGENTS_DIR, AGENT_EXT, ROSTER_FILE, EMA_ALPHA;
-var init_agent_loader = __esm({
-  "../paradigm-mcp/src/utils/agent-loader.ts"() {
-    init_agents();
-    GLOBAL_AGENTS_DIR = path.join(os.homedir(), ".paradigm", "agents");
-    PROJECT_AGENTS_DIR = ".paradigm/agents";
-    AGENT_EXT = ".agent";
-    ROSTER_FILE = ".paradigm/roster.yaml";
-    EMA_ALPHA = 0.3;
-  }
-});
-
-export {
-  loadProjectRoster,
-  isAgentActive,
-  saveProjectRoster,
-  listAllGlobalAgentIds,
-  loadAgentProfile,
-  loadAllAgentProfiles,
-  saveAgentProfile,
-  createAgentProfile,
-  queryExpertise,
-  updateExpertiseFromLore,
-  updateExpertiseFromAssessment,
-  mergeAgentProfileWithManifest,
-  buildProfileEnrichment,
-  syncExpertiseFromLore,
-  checkPathPermission,
-  checkToolPermission,
-  computeIntegrityHash,
-  verifyIntegrity,
-  init_agent_loader
-};