@a-company/paradigm 3.44.0 → 5.3.3

package/dist/chunk-7N7GSU6K.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/chunk-A2L4TSLZ.js

@@ -0,0 +1,526 @@
+#!/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" }
+    };
+    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 }
+    };
+    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 } }
+    };
+  }
+});
+
+// ../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 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) {
+  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 (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, 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";
+    EMA_ALPHA = 0.3;
+  }
+});
+
+export {
+  loadAgentProfile,
+  loadAllAgentProfiles,
+  saveAgentProfile,
+  createAgentProfile,
+  queryExpertise,
+  updateExpertiseFromLore,
+  updateExpertiseFromAssessment,
+  mergeAgentProfileWithManifest,
+  buildProfileEnrichment,
+  syncExpertiseFromLore,
+  checkPathPermission,
+  checkToolPermission,
+  computeIntegrityHash,
+  verifyIntegrity,
+  init_agent_loader
+};

package/dist/{chunk-P7XSBJE3.js → chunk-ABVQGRF7.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   indexCommand
-} from "./chunk-7COU5S2Z.js";
+} from "./chunk-VL67H5IC.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/{chunk-HIKKOCXY.js → chunk-EI32ZBE6.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-QWA26UNO.js";
+} from "./chunk-WQITYKHM.js";
 import {
   AGENT_MODEL_RECOMMENDATIONS,
   addActivity,

package/dist/{chunk-QIOCFXDQ.js → chunk-EKGMAM62.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   __require
-} from "./chunk-ZXMDA7VB.js";
+} from "./chunk-PDX44BCA.js";
 
 // src/core/lore/normalize.ts
 function inferProvider(model) {