@swarmvaultai/engine 3.15.0 → 3.16.1

package/README.md

@@ -215,6 +215,7 @@ The engine supports:
 - `together`
 - `xai`
 - `cerebras`
+- `local-whisper`
 - `openai-compatible`
 - `custom`
 
@@ -228,6 +229,7 @@ Providers are capability-driven. Each provider declares support for features suc
 - `streaming`
 - `local`
 - `image_generation`
+- `audio`
 
 This matters because many "OpenAI-compatible" backends only implement part of the OpenAI surface.
 
@@ -271,6 +273,7 @@ This matters because many "OpenAI-compatible" backends only implement part of th
 - `queryGraphVault(rootDir, question, { traversal, budget })` runs deterministic local graph search, preferring semantic seed matches from `tasks.embeddingProvider` when configured and falling back to lexical search plus matching group patterns otherwise
 - `pathGraphVault(rootDir, from, to)` returns the shortest graph path between two targets
 - `explainGraphVault(rootDir, target)` returns node, community, neighbor, provenance, and group-pattern details
+- `findGraphCycles(graph, { relations, limit, maxDepth })` returns deterministic directed cycles, commonly used for import or call-loop inspection
 - `listGraphHyperedges(rootDir, target?, limit?)` returns graph hyperedges globally or for a specific node/page target
 - `listGodNodes(rootDir, limit)` returns the most connected bridge-heavy graph nodes
 - `buildGraphShareArtifact(...)`, `renderGraphShareMarkdown(...)`, `renderGraphShareSvg(...)`, `renderGraphSharePreviewHtml(...)`, and `renderGraphShareBundleFiles(...)` produce the post-ready text, 1200x630 visual card, self-contained HTML preview, and portable share kit used by `wiki/graph/share-card.md`, `wiki/graph/share-card.svg`, `wiki/graph/share-kit/`, and the CLI `graph share` command
@@ -289,7 +292,9 @@ This matters because many "OpenAI-compatible" backends only implement part of th
 - large ingest and compile passes emit low-noise progress on TTYs, bound source-analysis concurrency, and use sparse graph co-occurrence projection so dense note sets do not create unbounded pairwise graph work
 - JSON state writes are atomic, and JSON parse failures include the exact state file path that failed to parse
 - `installGitHooks(rootDir)`, `uninstallGitHooks(rootDir)`, and `getGitHookStatus(rootDir)` manage local `post-commit` and `post-checkout` hook blocks for the nearest git repository
-- `installAgent(rootDir, agent, { hook })` writes agent instructions and returns the primary `target`, all touched `targets`, and optional merge warnings for agents such as Aider
+- `installAgent(rootDir, agent, { hook, scope })` writes agent instructions and returns the primary `target`, all touched `targets`, and optional merge warnings for agents such as Aider and Kilo
+- `getAgentInstallStatus(rootDir, agent, { scope })` reports expected install targets, presence, and managed-block status
+- `addProviderConfig`, `listProviderConfigEntries`, `getProviderConfigEntry`, and `removeProviderConfig` manage named provider entries and task routing in `swarmvault.config.json`
 - `lintVault(rootDir, options)` runs structural lint, optional deep lint, optional contradiction-only filtering through `{ conflicts: true }`, and optional web-augmented evidence gathering
 - `listSchedules(rootDir)`, `runSchedule(rootDir, jobId)`, and `serveSchedules(rootDir)` manage recurring local jobs from config
 - compile, query, explore, lint, and watch also write canonical markdown session artifacts to `state/sessions/`

package/dist/{chunk-NUWZUYE7.js → chunk-NON6BVEI.js}

@@ -66,9 +66,11 @@ var agentTypeSchema = z.enum([
   "cortex",
   "crush",
   "deepagents",
+  "devin",
   "firebender",
   "iflow",
   "junie",
+  "kilo",
   "kilo-code",
   "kimi",
   "kode",
@@ -1669,6 +1671,8 @@ async function getResolvedPaths(rootDir) {
 }
 
 export {
+  providerCapabilitySchema,
+  providerTypeSchema,
   slugify,
   sha256,
   ensureDir,

package/dist/{chunk-JJDJF2P3.js → chunk-TQIIJVVG.js}

@@ -22,7 +22,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-NUWZUYE7.js";
+} from "./chunk-NON6BVEI.js";
 import {
   estimateTokens
 } from "./chunk-NAIERP4C.js";
@@ -208,6 +208,7 @@ var agentFileKinds = {
   kiroSteering: ".kiro/steering/swarmvault.md",
   antigravityRules: ".agents/rules/swarmvault.md",
   antigravityWorkflow: ".agents/workflows/swarmvault.md",
+  devinRules: ".windsurf/rules/swarmvault.md",
   vscode: ".github/chatmodes/swarmvault.chatmode.md"
 };
 var legacyAntigravityFileKinds = {
@@ -226,6 +227,7 @@ var SKILL_BUNDLE_AGENTS = {
   cortex: ".snowflake/cortex/skills",
   crush: ".config/crush/skills",
   deepagents: ".deepagents/agent/skills",
+  devin: ".devin/skills",
   firebender: ".firebender/skills",
   iflow: ".iflow/skills",
   junie: ".junie/skills",
@@ -248,15 +250,53 @@ var SKILL_BUNDLE_AGENTS = {
   windsurf: ".codeium/windsurf/skills",
   zencoder: ".zencoder/skills"
 };
+var PROJECT_SKILL_TARGETS = {
+  antigravity: [".agents/skills"],
+  amp: [".amp/skills"],
+  codex: [".agents/skills"],
+  copilot: [".copilot/skills"],
+  devin: [".devin/skills"],
+  gemini: [".gemini/skills"],
+  kimi: [".kimi/skills"],
+  opencode: [".opencode/skills"],
+  pi: [".pi/agent/skills"],
+  vscode: [".copilot/skills"]
+};
+var USER_SKILL_TARGETS = {
+  antigravity: path2.join(".gemini", "config", "skills"),
+  amp: path2.join(".amp", "skills"),
+  codex: path2.join(".codex", "skills"),
+  copilot: path2.join(".copilot", "skills"),
+  devin: path2.join(".config", "devin", "skills"),
+  gemini: path2.join(".gemini", "skills"),
+  kimi: path2.join(".kimi", "skills"),
+  kilo: path2.join(".config", "kilo", "skills"),
+  opencode: path2.join(".config", "opencode", "skills"),
+  pi: path2.join(".pi", "agent", "skills"),
+  vscode: path2.join(".copilot", "skills")
+};
 function skillBundleTarget(rootDir, agent) {
   const relativeSkillsDir = SKILL_BUNDLE_AGENTS[agent];
   if (!relativeSkillsDir) return null;
   return path2.join(rootDir, relativeSkillsDir, "swarmvault", "SKILL.md");
 }
+function skillBundlePath(baseDir, relativeSkillsDir) {
+  return path2.join(baseDir, relativeSkillsDir, "swarmvault", "SKILL.md");
+}
+function projectSkillTargets(rootDir, agent) {
+  return (PROJECT_SKILL_TARGETS[agent] ?? []).map((relativeSkillsDir) => skillBundlePath(rootDir, relativeSkillsDir));
+}
+function userSkillTarget(agent) {
+  const relativeSkillsDir = USER_SKILL_TARGETS[agent];
+  return relativeSkillsDir ? skillBundlePath(os.homedir(), relativeSkillsDir) : null;
+}
 var hermesUserSkillRelative = path2.join(".hermes", "skills", "swarmvault", "SKILL.md");
 function hermesUserSkillPath() {
   return path2.join(os.homedir(), hermesUserSkillRelative);
 }
+function kiloUserCommandPath() {
+  return path2.join(os.homedir(), ".config", "kilo", "command", "swarmvault.md");
+}
 var SWARMVAULT_RULE_BULLETS = [
   "- Read `swarmvault.schema.md` before compile or query style work. It is the canonical schema path.",
   "- Treat `raw/` as immutable source input.",
@@ -357,6 +397,37 @@ function buildAntigravityWorkflowFile() {
     ""
   ].join("\n");
 }
+function buildKiloCommandFile() {
+  return [
+    "# /swarmvault",
+    "",
+    "Use SwarmVault's graph-first workflow in the current project.",
+    "",
+    "1. If no vault exists, run `swarmvault init`.",
+    "2. Read `wiki/graph/report.md` before broad source search when it exists.",
+    "3. Prefer `swarmvault graph query`, `swarmvault graph path`, and `swarmvault graph explain` for structure questions.",
+    "4. Run `swarmvault compile` after adding or refreshing sources.",
+    ""
+  ].join("\n");
+}
+function buildKiloPluginFile() {
+  return [
+    "export default async function SwarmVaultPlugin({ project }) {",
+    "  return {",
+    "    name: 'swarmvault-graph-first',",
+    "    async beforeToolUse(event) {",
+    "      const toolName = event?.tool?.name ?? event?.toolName ?? '';",
+    "      if (!['bash', 'shell', 'terminal', 'search', 'grep', 'glob'].includes(String(toolName).toLowerCase())) return;",
+    "      const root = project?.root ?? process.cwd();",
+    "      return {",
+    "        message: `SwarmVault graph guidance: from ${root}, read wiki/graph/report.md first when it exists, or run swarmvault graph query/path/explain before broad search.`",
+    "      };",
+    "    }",
+    "  };",
+    "}",
+    ""
+  ].join("\n");
+}
 function buildVscodeChatmodeFile() {
   const frontmatter = YAML.stringify({
     description: "SwarmVault graph-first workflow for VS Code Copilot Chat.",
@@ -387,10 +458,20 @@ function buildCursorRule() {
   return ["---", frontmatter, "---", "", buildManagedBlock("cursor").trimEnd(), ""].join("\n");
 }
 function supportsAgentHook(agent) {
-  return agent === "codex" || agent === "claude" || agent === "opencode" || agent === "gemini" || agent === "copilot";
+  return agent === "codex" || agent === "claude" || agent === "opencode" || agent === "gemini" || agent === "copilot" || agent === "kilo";
+}
+function installScope(agent, options = {}) {
+  if (options.scope) return options.scope;
+  return agent === "hermes" ? "user" : "project";
 }
-function primaryTargetPathForAgent(rootDir, agent) {
+function primaryTargetPathForAgent(rootDir, agent, options = {}) {
+  if (installScope(agent, options) === "user") {
+    if (agent === "hermes") return hermesUserSkillPath();
+    const target = userSkillTarget(agent);
+    if (target) return target;
+  }
   switch (agent) {
+    case "kilo":
     case "codex":
     case "goose":
     case "pi":
@@ -435,6 +516,8 @@ function hookScriptPathForAgent(rootDir, agent) {
       return path2.join(rootDir, ".claude", "hooks", "swarmvault-graph-first.js");
     case "opencode":
       return path2.join(rootDir, ".opencode", "plugins", "swarmvault-graph-first.js");
+    case "kilo":
+      return path2.join(rootDir, ".kilo", "plugins", "swarmvault.js");
     case "gemini":
       return path2.join(rootDir, ".gemini", "hooks", "swarmvault-graph-first.js");
     case "copilot":
@@ -451,6 +534,10 @@ function hookConfigPathForAgent(rootDir, agent) {
       return path2.join(rootDir, ".claude", "settings.json");
     case "gemini":
       return path2.join(rootDir, ".gemini", "settings.json");
+    case "opencode":
+      return path2.join(rootDir, ".opencode", "opencode.json");
+    case "kilo":
+      return path2.join(rootDir, ".kilo", "kilo.json");
     case "copilot":
       return path2.join(rootDir, ".github", "hooks", "swarmvault-graph-first.json");
     default:
@@ -458,7 +545,20 @@ function hookConfigPathForAgent(rootDir, agent) {
   }
 }
 function targetsForAgent(rootDir, agent, options = {}) {
-  const targets = [primaryTargetPathForAgent(rootDir, agent)];
+  const scope = installScope(agent, options);
+  const targets = [primaryTargetPathForAgent(rootDir, agent, options)];
+  if (scope === "user") {
+    if (agent === "kilo") {
+      targets.push(kiloUserCommandPath());
+    }
+    if (agent === "hermes") {
+      targets.push(path2.join(rootDir, agentFileKinds.agents));
+    }
+    return [...new Set(targets)];
+  }
+  if (options.scope === "project") {
+    targets.push(...projectSkillTargets(rootDir, agent));
+  }
   if (agent === "copilot") {
     targets.push(path2.join(rootDir, agentFileKinds.agents));
   }
@@ -477,6 +577,9 @@ function targetsForAgent(rootDir, agent, options = {}) {
   if (agent === "antigravity") {
     targets.push(path2.join(rootDir, agentFileKinds.antigravityWorkflow));
   }
+  if (agent === "devin") {
+    targets.push(path2.join(rootDir, agentFileKinds.devinRules));
+  }
   if (options.hook && supportsAgentHook(agent)) {
     const configPath = hookConfigPathForAgent(rootDir, agent);
     const scriptPath = hookScriptPathForAgent(rootDir, agent);
@@ -557,6 +660,85 @@ async function readJsonWithWarnings(filePath, fallback, label) {
     };
   }
 }
+function stripJsonComments(source) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const current = source[index] ?? "";
+    const next = source[index + 1] ?? "";
+    if (inLineComment) {
+      if (current === "\n" || current === "\r") {
+        inLineComment = false;
+        output += current;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      } else if (current === "\n" || current === "\r") {
+        output += current;
+      }
+      continue;
+    }
+    if (inString) {
+      output += current;
+      if (escaped) {
+        escaped = false;
+      } else if (current === "\\") {
+        escaped = true;
+      } else if (current === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (current === '"') {
+      inString = true;
+      output += current;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    output += current;
+  }
+  return output;
+}
+async function readJsonOrJsoncWithWarnings(jsonPath, jsoncPath, fallback, label) {
+  if (await fileExists(jsonPath)) {
+    return readJsonWithWarnings(jsonPath, fallback, label);
+  }
+  if (!await fileExists(jsoncPath)) {
+    return { data: fallback, warnings: [] };
+  }
+  try {
+    const parsed = JSON.parse(stripJsonComments(await fs2.readFile(jsoncPath, "utf8")));
+    return { data: parsed, warnings: [] };
+  } catch {
+    return {
+      data: fallback,
+      warnings: [`Could not parse ${label}. Left the existing file unchanged.`]
+    };
+  }
+}
+function withPluginEntry(config, pluginEntry) {
+  const existing = Array.isArray(config.plugins) ? config.plugins.filter((entry) => typeof entry === "string") : [];
+  return {
+    ...config,
+    plugins: existing.includes(pluginEntry) ? existing : [...existing, pluginEntry]
+  };
+}
 async function installClaudeHook(rootDir) {
   const settingsPath = path2.join(rootDir, ".claude", "settings.json");
   const scriptPath = path2.join(rootDir, ".claude", "hooks", "swarmvault-graph-first.js");
@@ -724,8 +906,33 @@ async function installCopilotHook(rootDir) {
 }
 async function installOpenCodeHook(rootDir) {
   const pluginPath = path2.join(rootDir, ".opencode", "plugins", "swarmvault-graph-first.js");
+  const configPath = path2.join(rootDir, ".opencode", "opencode.json");
   await writeOwnedFile(pluginPath, await readBuiltHook("opencode.js"));
-  return { paths: [pluginPath], warnings: [] };
+  const { data: config, warnings } = await readJsonWithWarnings(configPath, {}, ".opencode/opencode.json");
+  if (warnings.length > 0 && await fileExists(configPath)) {
+    return { paths: [pluginPath, configPath], warnings };
+  }
+  await writeOwnedFile(configPath, `${JSON.stringify(withPluginEntry(config, "./plugins/swarmvault-graph-first.js"), null, 2)}
+`);
+  return { paths: [pluginPath, configPath], warnings: [] };
+}
+async function installKiloHook(rootDir) {
+  const pluginPath = path2.join(rootDir, ".kilo", "plugins", "swarmvault.js");
+  const configPath = path2.join(rootDir, ".kilo", "kilo.json");
+  const jsoncPath = path2.join(rootDir, ".kilo", "kilo.jsonc");
+  await writeOwnedFile(pluginPath, buildKiloPluginFile());
+  const { data: config, warnings } = await readJsonOrJsoncWithWarnings(
+    configPath,
+    jsoncPath,
+    {},
+    ".kilo/kilo.json or .kilo/kilo.jsonc"
+  );
+  if (warnings.length > 0 && (await fileExists(configPath) || await fileExists(jsoncPath))) {
+    return { paths: [pluginPath, configPath], warnings };
+  }
+  await writeOwnedFile(configPath, `${JSON.stringify(withPluginEntry(config, "./plugins/swarmvault.js"), null, 2)}
+`);
+  return { paths: [pluginPath, configPath], warnings: [] };
 }
 function stableKeyForAgent(rootDir, agent) {
   if (agent === "codex" || agent === "goose" || agent === "pi") {
@@ -735,9 +942,28 @@ function stableKeyForAgent(rootDir, agent) {
 }
 async function installAgent(rootDir, agent, options = {}) {
   await initWorkspace(rootDir);
-  const target = primaryTargetPathForAgent(rootDir, agent);
+  const scope = installScope(agent, options);
+  const target = primaryTargetPathForAgent(rootDir, agent, options);
   const warnings = [];
+  if (scope === "user") {
+    if (agent === "hermes") {
+      await upsertManagedBlock(path2.join(rootDir, agentFileKinds.agents), buildManagedBlock("agents"));
+      await writeOwnedFile(hermesUserSkillPath(), buildStandaloneSkillFile());
+    } else {
+      const userTarget = userSkillTarget(agent);
+      if (!userTarget) {
+        throw new Error(`User-scope install is not supported for agent ${String(agent)}`);
+      }
+      await writeOwnedFile(userTarget, buildStandaloneSkillFile());
+      if (agent === "kilo") {
+        await writeOwnedFile(kiloUserCommandPath(), buildKiloCommandFile());
+      }
+    }
+    const targets2 = targetsForAgent(rootDir, agent, options);
+    return warnings.length > 0 ? { agent, target, targets: targets2, warnings } : { agent, target, targets: targets2 };
+  }
   switch (agent) {
+    case "kilo":
     case "codex":
     case "goose":
     case "pi":
@@ -798,6 +1024,14 @@ async function installAgent(rootDir, agent, options = {}) {
     const aiderResult = await mergeAiderConfig(rootDir);
     warnings.push(...aiderResult.warnings);
   }
+  if (options.scope === "project") {
+    for (const skillTarget of projectSkillTargets(rootDir, agent)) {
+      await writeOwnedFile(skillTarget, buildStandaloneSkillFile());
+    }
+  }
+  if (agent === "devin") {
+    await writeOwnedFile(path2.join(rootDir, agentFileKinds.devinRules), buildManagedBlock("devinRules"));
+  }
   if (options.hook && supportsAgentHook(agent)) {
     if (agent === "codex") {
       const result = await installCodexHook(rootDir);
@@ -811,6 +1045,10 @@ async function installAgent(rootDir, agent, options = {}) {
       const result = await installOpenCodeHook(rootDir);
       warnings.push(...result.warnings);
     }
+    if (agent === "kilo") {
+      const result = await installKiloHook(rootDir);
+      warnings.push(...result.warnings);
+    }
     if (agent === "gemini") {
       const result = await installGeminiHook(rootDir);
       warnings.push(...result.warnings);
@@ -823,6 +1061,24 @@ async function installAgent(rootDir, agent, options = {}) {
   const targets = targetsForAgent(rootDir, agent, options);
   return warnings.length > 0 ? { agent, target, targets, warnings } : { agent, target, targets };
 }
+async function getAgentInstallStatus(rootDir, agent, options = {}) {
+  const target = primaryTargetPathForAgent(rootDir, agent, options);
+  const targets = targetsForAgent(rootDir, agent, options);
+  const targetStatuses = await Promise.all(
+    targets.map(async (targetPath) => ({
+      path: targetPath,
+      exists: await fileExists(targetPath)
+    }))
+  );
+  return {
+    agent,
+    scope: installScope(agent, options),
+    hook: options.hook ?? false,
+    target,
+    targets: targetStatuses,
+    installed: targetStatuses.length > 0 && targetStatuses.every((entry) => entry.exists)
+  };
+}
 async function installConfiguredAgents(rootDir) {
   const { config } = await initWorkspace(rootDir);
   const dedupedAgents = /* @__PURE__ */ new Map();
@@ -15779,6 +16035,79 @@ function graphDiff(oldGraph, newGraph) {
   const summary = parts.length ? parts.join("; ") : "No changes";
   return { addedNodes, removedNodes, addedEdges, removedEdges, addedPages, removedPages, summary };
 }
+function findGraphCycles(graph, options = {}) {
+  const relationFilter = options.relations?.length ? new Set(options.relations) : null;
+  const limit = Math.max(1, Math.min(options.limit ?? 25, 250));
+  const maxDepth = Math.max(2, Math.min(options.maxDepth ?? 25, 100));
+  const nodes = nodeById(graph);
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (relationFilter && !relationFilter.has(edge.relation)) {
+      continue;
+    }
+    if (!nodes.has(edge.source) || !nodes.has(edge.target)) {
+      continue;
+    }
+    const outgoing = adjacency.get(edge.source) ?? [];
+    outgoing.push(edge);
+    adjacency.set(edge.source, outgoing);
+  }
+  for (const [nodeId, edges] of adjacency.entries()) {
+    adjacency.set(
+      nodeId,
+      edges.sort(
+        (left, right) => left.target.localeCompare(right.target) || left.relation.localeCompare(right.relation) || left.id.localeCompare(right.id)
+      )
+    );
+  }
+  const cycles = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  const sortedNodeIds = [...nodes.keys()].sort((left, right) => left.localeCompare(right));
+  const addCycle = (nodeIds, edges) => {
+    const key = nodeIds.join(">");
+    if (seenKeys.has(key)) {
+      return;
+    }
+    seenKeys.add(key);
+    cycles.push({
+      nodeIds,
+      labels: nodeIds.map((nodeId) => nodes.get(nodeId)?.label ?? nodeId),
+      edgeIds: edges.map((edge) => edge.id),
+      relations: edges.map((edge) => edge.relation)
+    });
+  };
+  const visit = (startId, currentId, pathNodeIds, pathEdges, visited) => {
+    if (cycles.length >= limit || pathNodeIds.length > maxDepth) {
+      return;
+    }
+    for (const edge of adjacency.get(currentId) ?? []) {
+      const nextId = edge.target;
+      if (nextId === startId && pathNodeIds.length > 1) {
+        addCycle([...pathNodeIds], [...pathEdges, edge]);
+        if (cycles.length >= limit) return;
+        continue;
+      }
+      if (visited.has(nextId) || nextId.localeCompare(startId) < 0) {
+        continue;
+      }
+      visited.add(nextId);
+      visit(startId, nextId, [...pathNodeIds, nextId], [...pathEdges, edge], visited);
+      visited.delete(nextId);
+      if (cycles.length >= limit) return;
+    }
+  };
+  for (const startId of sortedNodeIds) {
+    visit(startId, startId, [startId], [], /* @__PURE__ */ new Set([startId]));
+    if (cycles.length >= limit) {
+      break;
+    }
+  }
+  cycles.sort(
+    (left, right) => left.labels.join(" > ").localeCompare(right.labels.join(" > ")) || left.nodeIds.join(">").localeCompare(right.nodeIds.join(">"))
+  );
+  const summary = cycles.length ? `Found ${cycles.length} cycle${cycles.length === 1 ? "" : "s"}${cycles.length >= limit ? ` (limited to ${limit})` : ""}.` : "No cycles found.";
+  return { cycles, limit, summary };
+}
 function blastRadius(graph, target, options) {
   const maxDepth = Math.max(1, Math.min(options?.maxDepth ?? 3, 10));
   const resolved = resolveNode(graph, target);
@@ -20150,7 +20479,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-ILDEBNCW.js");
+  const { createProvider: createProvider2 } = await import("./registry-ZZ6NESFD.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -26120,13 +26449,13 @@ async function buildContextPack(rootDir, options) {
       }
     }
   }
-  const memorySummaries = await import("./memory-PK55JUKG.js").then(({ listMemoryTasks: listMemoryTasks2 }) => listMemoryTasks2(rootDir)).catch(() => []);
+  const memorySummaries = await import("./memory-4BDKH4Y2.js").then(({ listMemoryTasks: listMemoryTasks2 }) => listMemoryTasks2(rootDir)).catch(() => []);
   const memorySummaryIds = uniqueStrings5([
     ...options.memoryTaskId ? [options.memoryTaskId] : [],
     ...memorySummaries.slice(0, 20).map((summary) => summary.id)
   ]);
   if (memorySummaryIds.length) {
-    const { readMemoryTask: readMemoryTask2 } = await import("./memory-PK55JUKG.js");
+    const { readMemoryTask: readMemoryTask2 } = await import("./memory-4BDKH4Y2.js");
     for (const taskId of memorySummaryIds) {
       const task = await readMemoryTask2(rootDir, taskId).catch(() => null);
       if (!task) {
@@ -26205,7 +26534,7 @@ async function buildContextPack(rootDir, options) {
     ]
   });
   if (options.memoryTaskId) {
-    const { updateMemoryTask: updateMemoryTask2 } = await import("./memory-PK55JUKG.js");
+    const { updateMemoryTask: updateMemoryTask2 } = await import("./memory-4BDKH4Y2.js");
     await updateMemoryTask2(rootDir, options.memoryTaskId, { contextPackId: pack.id });
   }
   return {
@@ -26879,6 +27208,7 @@ function estimateMemoryTaskTokens(task) {
 
 export {
   installAgent,
+  getAgentInstallStatus,
   installConfiguredAgents,
   DEFAULT_PROMOTION_CONFIG,
   evaluateCandidateForPromotion,
@@ -26920,6 +27250,7 @@ export {
   graphStats,
   validateGraphArtifact,
   graphDiff,
+  findGraphCycles,
   blastRadius,
   LARGE_REPO_NODE_THRESHOLD,
   resolveLargeRepoDefaults,