agents-inc 0.164.0 → 0.166.0

package/dist/chunk-GE3WKJ6Q.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+import {
+  agentCodec,
+  buildAgentTemplateContext,
+  buildCompileAgents,
+  directoryExists,
+  discoverAllPluginSkills,
+  ensureDir,
+  fileExists,
+  getErrorMessage,
+  getPluginAgentsDir,
+  glob,
+  hostCompilesAgent,
+  isAgentName,
+  loadAllAgents,
+  loadProjectAgents,
+  loadProjectConfig,
+  pluginRefFor,
+  providerInUse,
+  readFile,
+  readFileOptional,
+  remove,
+  renderAgent,
+  renderAgentBody,
+  renderAgentRoleToml,
+  resolveAgents,
+  resolveInstallPaths,
+  sourceFolderInUse,
+  sourceFolderName,
+  verbose,
+  writeFile
+} from "./chunk-A4KDXNOT.js";
+import {
+  typedEntries,
+  typedFromEntries,
+  typedKeys
+} from "./chunk-V5WXIM2F.js";
+import {
+  CLAUDE_DIR,
+  DIRS,
+  PROJECT_ROOT,
+  STANDARD_DIRS,
+  STANDARD_FILES,
+  effectivelyExcludedSkillIds
+} from "./chunk-ENGYJCTF.js";
+
+// src/cli/lib/agents/list-compiled-agents.ts
+import path from "path";
+import { partition } from "remeda";
+var CLAUDE_AGENTS = agentCodec("claude");
+async function listAgentMdFiles(agentsDir) {
+  return listAgentFilesOf(agentsDir, CLAUDE_AGENTS);
+}
+async function listAgentFilesOf(agentsDir, codec) {
+  return glob(codec.listGlob, agentsDir);
+}
+async function splitAgentsByProvenance(agentsDir, codec = CLAUDE_AGENTS) {
+  const files = await listAgentFilesOf(agentsDir, codec);
+  const classified = await Promise.all(
+    files.map((file) => readAgentProvenance(agentsDir, file, codec))
+  );
+  const [marked, unmarked] = partition(classified, (agent) => agent.compiledHere);
+  return { marked: marked.map(agentName), unmarked: unmarked.map(agentName) };
+}
+async function readAgentProvenance(agentsDir, file, codec) {
+  const content = await readFileOptional(path.join(agentsDir, file));
+  return { name: path.basename(file, codec.extension), compiledHere: codec.hasMarker(content) };
+}
+function agentName(agent) {
+  return agent.name;
+}
+async function listCompiledAgentNames(agentsDir) {
+  const files = await listAgentMdFiles(agentsDir);
+  return files.map((f) => path.basename(f, ".md"));
+}
+async function pruneStaleCompiledAgents(agentsDir, keep, codec = CLAUDE_AGENTS) {
+  const isStaleCompiledAgent = (file) => {
+    const name = path.basename(file, codec.extension);
+    return isAgentName(name) && !keep.has(name);
+  };
+  const files = await listAgentFilesOf(agentsDir, codec);
+  await Promise.all(
+    files.filter(isStaleCompiledAgent).map((file) => remove(path.join(agentsDir, file)))
+  );
+}
+
+// src/cli/lib/agents/agent-recompiler.ts
+import { partition as partition2 } from "remeda";
+
+// src/cli/lib/agents/write-compiled-agents.ts
+import os from "os";
+import path4 from "path";
+
+// src/cli/lib/compiler.ts
+import { Liquid } from "liquidjs";
+import path3 from "path";
+
+// src/cli/lib/agents/agent-provenance.ts
+import path2 from "path";
+import { z } from "zod";
+var ownPackageJsonSchema = z.object({ version: z.string().min(1) });
+var ownVersion;
+function cliVersion() {
+  ownVersion ??= readOwnVersion();
+  return ownVersion;
+}
+async function readOwnVersion() {
+  const manifestPath = path2.join(PROJECT_ROOT, STANDARD_FILES.PACKAGE_JSON);
+  const raw = JSON.parse(await readFile(manifestPath));
+  const parsed = ownPackageJsonSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`Could not read this CLI's own version from ${manifestPath}`);
+  }
+  return parsed.data.version;
+}
+
+// src/cli/lib/compiler.ts
+async function readAgentFiles(name, agent, projectRoot) {
+  const agentSourceRoot = agent.sourceRoot || projectRoot;
+  const agentBaseDir = agent.agentBaseDir || DIRS.agents;
+  const agentPath = agent.path || name;
+  const agentDir = path3.join(agentSourceRoot, agentBaseDir, agentPath);
+  const identity = await readFile(path3.join(agentDir, STANDARD_FILES.IDENTITY_MD));
+  const playbook = await readFile(path3.join(agentDir, STANDARD_FILES.PLAYBOOK_MD));
+  const criticalRequirementsTop = await readFileOptional(
+    path3.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),
+    ""
+  );
+  const criticalReminders = await readFileOptional(
+    path3.join(agentDir, STANDARD_FILES.CRITICAL_REMINDERS_MD),
+    ""
+  );
+  const category = agentPath.split("/")[0] || name;
+  const categoryDir = path3.join(agentSourceRoot, agentBaseDir, category);
+  const output = await readOutputPartial(agentDir, categoryDir);
+  return { identity, playbook, output, criticalRequirementsTop, criticalReminders };
+}
+async function readOutputPartial(agentDir, categoryDir) {
+  const own = await readFileOptional(path3.join(agentDir, STANDARD_FILES.OUTPUT_MD), "");
+  if (own) return own;
+  return readFileOptional(path3.join(categoryDir, STANDARD_FILES.OUTPUT_MD), "");
+}
+async function createLiquidEngine(projectDir) {
+  const roots = [];
+  const provider = providerInUse(projectDir);
+  if (projectDir) {
+    const srcTemplatesDir = path3.join(
+      sourceFolderInUse(projectDir, provider).dir,
+      STANDARD_DIRS.AGENTS,
+      path3.basename(DIRS.templates)
+    );
+    if (await directoryExists(srcTemplatesDir)) {
+      roots.push(srcTemplatesDir);
+      verbose(`Using local templates from: ${srcTemplatesDir}`);
+    }
+    const legacyTemplatesDir = path3.join(projectDir, CLAUDE_DIR, STANDARD_DIRS.TEMPLATES);
+    if (await directoryExists(legacyTemplatesDir)) {
+      roots.push(legacyTemplatesDir);
+      verbose(`Using legacy templates from: ${legacyTemplatesDir}`);
+    }
+  }
+  roots.push(path3.join(PROJECT_ROOT, DIRS.templates));
+  return new Liquid({
+    root: roots,
+    extname: ".liquid",
+    strictVariables: false,
+    strictFilters: true,
+    globals: { sourceFolder: sourceFolderName(projectDir, provider) }
+  });
+}
+async function compileAgentForHost(provider, name, agent, fallbackRoot, engine) {
+  verbose(`Compiling agent: ${name} (${provider})`);
+  const files = await readAgentFiles(name, agent, fallbackRoot);
+  const data = buildAgentTemplateContext(name, agent, files, (skill) => ({
+    ...skill,
+    ...pluginRefFor(skill)
+  }));
+  const version = await cliVersion();
+  switch (provider) {
+    case "claude":
+      return renderAgent(engine, data, version);
+    case "codex":
+      return renderAgentRoleToml(agent, await renderAgentBody(engine, data, version));
+    default: {
+      const _exhaustive = provider;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/cli/lib/agents/write-compiled-agents.ts
+async function holdsExactly(filePath, content) {
+  return await fileExists(filePath) && await readFile(filePath) === content;
+}
+var UNROUTED_AGENT_SCOPE = "project";
+async function writeCompiledAgentsByScope(params) {
+  const hosts = {
+    // Each scope reads its OWN root, the way `resolveInstallPaths` reads one beside this: a
+    // project on Codex under a global on Claude is an arrangement this product allows, and one
+    // provider answered for both scopes is how a pass writes the wrong format into one of them.
+    global: {
+      provider: providerInUse(os.homedir()),
+      agentsDir: resolveInstallPaths(os.homedir(), "global").agentsDir
+    },
+    project: { provider: providerInUse(params.projectDir), agentsDir: params.projectAgentsDir }
+  };
+  const outcomes = [];
+  for (const [name, agent] of typedEntries(params.resolvedAgents)) {
+    const scope = params.agentScopeMap?.get(name) ?? UNROUTED_AGENT_SCOPE;
+    const host = hosts[scope];
+    if (!hostCompilesAgent(host.provider, name)) continue;
+    outcomes.push(await writeOneAgent({ ...params, name, agent, scope, host }));
+  }
+  return outcomes;
+}
+async function writeOneAgent(params) {
+  const { name, scope, host } = params;
+  try {
+    const output = await compileAgentForHost(
+      host.provider,
+      name,
+      params.agent,
+      params.sourcePath,
+      params.engine
+    );
+    const targetPath = path4.join(host.agentsDir, fileNameFor(name, host.provider));
+    const rewritten = !await holdsExactly(targetPath, output);
+    if (rewritten) await writeFile(targetPath, output);
+    return { name, ok: true, scope, targetDir: host.agentsDir, rewritten };
+  } catch (error) {
+    return { name, ok: false, error };
+  }
+}
+function fileNameFor(name, provider) {
+  return `${name}${agentCodec(provider).extension}`;
+}
+
+// src/cli/lib/agents/agent-recompiler.ts
+import path5 from "path";
+async function getExistingAgentNames(pluginDir) {
+  return listCompiledAgentNames(getPluginAgentsDir(pluginDir));
+}
+async function resolveAgentNames(params) {
+  const { specifiedAgents, projectConfig, allAgents, outputDir, pluginDir } = params;
+  if (specifiedAgents) {
+    return specifiedAgents;
+  }
+  if (projectConfig) {
+    const agentNames = projectConfig.agents.map((a) => a.name);
+    verbose(`Using agents from config: ${agentNames.join(", ")}`);
+    return agentNames;
+  }
+  if (outputDir) {
+    const names = typedKeys(allAgents);
+    verbose(`Using all available agents from source: ${names.join(", ")}`);
+    return names;
+  }
+  return getExistingAgentNames(pluginDir);
+}
+function buildRecompileResult(outcomes, priorWarnings) {
+  const [succeeded, failedOutcomes] = partition2(
+    outcomes,
+    (outcome) => outcome.ok
+  );
+  succeeded.forEach(
+    (outcome) => verbose(
+      `  ${outcome.rewritten ? "Rewrote" : "Unchanged"}: ${outcome.name} (${outcome.scope} -> ${outcome.targetDir})`
+    )
+  );
+  return {
+    compiled: succeeded.map((outcome) => outcome.name),
+    rewritten: succeeded.filter((outcome) => outcome.rewritten).map((outcome) => outcome.name),
+    failed: failedOutcomes.map((outcome) => outcome.name),
+    warnings: [
+      ...priorWarnings,
+      ...failedOutcomes.map(
+        (outcome) => `Failed to compile ${outcome.name}: ${getErrorMessage(outcome.error)}`
+      )
+    ]
+  };
+}
+function filterExcludedEntries(config) {
+  const excludedIds = effectivelyExcludedSkillIds(config.skills);
+  const activeSkills = config.skills.filter((s) => !s.excluded);
+  const activeAgents = config.agents.filter((a) => !a.excluded);
+  const filteredStack = config.stack === void 0 ? {} : { stack: withoutExcludedAssignments(config.stack, excludedIds) };
+  return { ...config, skills: activeSkills, agents: activeAgents, ...filteredStack };
+}
+function withoutExcludedAssignments(stack, excludedIds) {
+  return Object.fromEntries(
+    typedEntries(stack).map(([agentName2, agentStack]) => [
+      agentName2,
+      Object.fromEntries(
+        typedEntries(agentStack).map(([category, assignments]) => [
+          category,
+          assignments.filter((assignment) => !excludedIds.has(assignment.id))
+        ])
+      )
+    ])
+  );
+}
+async function recompileAgents(options) {
+  const { pluginDir, sourcePath, skills: providedSkills, projectDir, outputDir } = options;
+  const configDir = projectDir ?? pluginDir;
+  const loadedConfig = await loadProjectConfig(configDir);
+  const projectConfig = loadedConfig?.config ?? null;
+  const filteredConfig = projectConfig ? filterExcludedEntries(projectConfig) : null;
+  const builtinAgents = await loadAllAgents(sourcePath);
+  const projectAgents = projectDir ? await loadProjectAgents(projectDir) : {};
+  const allAgents = {
+    ...builtinAgents,
+    ...projectAgents
+  };
+  const agentNames = await resolveAgentNames({
+    ...options.agents !== void 0 && { specifiedAgents: options.agents },
+    projectConfig: filteredConfig,
+    allAgents,
+    ...outputDir !== void 0 && { outputDir },
+    pluginDir
+  });
+  if (agentNames.length === 0) {
+    return { compiled: [], rewritten: [], failed: [], warnings: [] };
+  }
+  verbose(`Recompiling ${agentNames.length} agents in ${outputDir ?? pluginDir}`);
+  const pluginSkills = providedSkills ?? await discoverAllPluginSkills(projectDir ?? pluginDir);
+  const { configAgents, missingWarnings } = compileEntriesFor(
+    agentNames,
+    filteredConfig,
+    allAgents
+  );
+  const compileConfig = {
+    name: filteredConfig?.name || path5.basename(pluginDir),
+    description: filteredConfig?.description || "Recompiled plugin",
+    agents: configAgents
+  };
+  const engine = await createLiquidEngine(projectDir);
+  const resolvedAgents = await resolveAgents(allAgents, pluginSkills, compileConfig, sourcePath);
+  const agentsDir = outputDir ?? getPluginAgentsDir(pluginDir);
+  await ensureDir(agentsDir);
+  const outcomes = await writeCompiledAgentsByScope({
+    resolvedAgents,
+    sourcePath,
+    engine,
+    projectAgentsDir: agentsDir,
+    // The same root this pass loaded its config from, so the provider that decides the FORMAT
+    // and the provider that decided the configuration are read off one installation.
+    projectDir: configDir,
+    ...options.agentScopeMap !== void 0 && { agentScopeMap: options.agentScopeMap }
+  });
+  return buildRecompileResult(outcomes, missingWarnings);
+}
+function compileEntriesFor(agentNames, config, allAgents) {
+  const allConfigAgents = config ? buildCompileAgents(config, allAgents) : {};
+  const [knownAgents, missingAgents] = partition2(
+    agentNames,
+    (name) => Boolean(allConfigAgents[name] || allAgents[name])
+  );
+  return {
+    configAgents: typedFromEntries(
+      knownAgents.map((name) => [name, allConfigAgents[name] ?? {}])
+    ),
+    missingWarnings: missingAgents.map((name) => `Agent "${name}" not found in source definitions`)
+  };
+}
+
+export {
+  listAgentMdFiles,
+  listAgentFilesOf,
+  splitAgentsByProvenance,
+  pruneStaleCompiledAgents,
+  filterExcludedEntries,
+  withoutExcludedAssignments,
+  recompileAgents
+};
+//# sourceMappingURL=chunk-GE3WKJ6Q.js.map

package/dist/chunk-GE3WKJ6Q.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/lib/agents/list-compiled-agents.ts","../src/cli/lib/agents/agent-recompiler.ts","../src/cli/lib/agents/write-compiled-agents.ts","../src/cli/lib/compiler.ts","../src/cli/lib/agents/agent-provenance.ts"],"sourcesContent":["import path from \"path\";\nimport { partition } from \"remeda\";\nimport { glob, readFileOptional, remove } from \"../../utils/fs\";\nimport { isAgentName } from \"../../utils/type-guards\";\nimport { type AgentCodec, agentCodec } from \"../installation/install-layout\";\nimport type { AgentName } from \"../../types\";\n\n/**\n * Claude's codec, the default every reader below falls back to. A caller holding an installation\n * of another host passes that host's — `agentCodec(providerInUse(dir))` — because a Codex role is a\n * `.toml` whose marker sits inside `developer_instructions`, and a reader that only knew `*.md`\n * found no compiled agent on Codex at all: `uninstall` left every role behind while saying it had\n * removed them (CLI-896, found on a real Codex run 2026-09-26).\n */\nconst CLAUDE_AGENTS = agentCodec(\"claude\");\n\n/** Compiled-agent basenames in a directory, split by whether this CLI compiled them. */\nexport type AgentProvenanceSplit = {\n  /** Files carrying the provenance marker — provably written by this CLI. */\n  marked: string[];\n  /** Everything else in the directory, the user's own agents among them. */\n  unmarked: string[];\n};\n\n/** Lists compiled-agent markdown filenames (e.g. \"web-developer.md\") in a directory. */\nexport async function listAgentMdFiles(agentsDir: string): Promise<string[]> {\n  return listAgentFilesOf(agentsDir, CLAUDE_AGENTS);\n}\n\n/** Lists the compiled-agent files `codec`'s host keeps in a directory (`*.md`, `*.toml`). */\nexport async function listAgentFilesOf(agentsDir: string, codec: AgentCodec): Promise<string[]> {\n  return glob(codec.listGlob, agentsDir);\n}\n\n/**\n * Splits the agent files in a directory by the provenance marker each compiled agent carries.\n *\n * This is the only thing that identifies this CLI's own output once the configuration naming\n * it is gone, so the split errs one way by construction: a file that cannot be read yields no\n * marker and lands in `unmarked`, because \"cannot prove it is ours\" and \"is not ours\" call for\n * the same answer — leave it alone.\n */\nexport async function splitAgentsByProvenance(\n  agentsDir: string,\n  codec: AgentCodec = CLAUDE_AGENTS,\n): Promise<AgentProvenanceSplit> {\n  const files = await listAgentFilesOf(agentsDir, codec);\n  const classified = await Promise.all(\n    files.map((file) => readAgentProvenance(agentsDir, file, codec)),\n  );\n  const [marked, unmarked] = partition(classified, (agent) => agent.compiledHere);\n\n  return { marked: marked.map(agentName), unmarked: unmarked.map(agentName) };\n}\n\ntype ClassifiedAgent = { name: string; compiledHere: boolean };\n\nasync function readAgentProvenance(\n  agentsDir: string,\n  file: string,\n  codec: AgentCodec,\n): Promise<ClassifiedAgent> {\n  const content = await readFileOptional(path.join(agentsDir, file));\n  return { name: path.basename(file, codec.extension), compiledHere: codec.hasMarker(content) };\n}\n\nfunction agentName(agent: ClassifiedAgent): string {\n  return agent.name;\n}\n\n/** Lists compiled-agent names (filenames without the `.md` extension) in a directory. */\nexport async function listCompiledAgentNames(agentsDir: string): Promise<AgentName[]> {\n  const files = await listAgentMdFiles(agentsDir);\n  // Boundary cast: compiled .md filenames are agent names by convention; custom\n  // agents from marketplace stacks may not be members of the AgentName union.\n  return files.map((f) => path.basename(f, \".md\") as AgentName);\n}\n\n/**\n * Removes stale CLI-compiled agent files from `agentsDir`: deletes any agent file (`codec`'s\n * extension) whose basename is a built-in CLI agent name (`isAgentName`) that is NOT in\n * `keep`. The built-in-name check protects hand-authored agents (whose basename\n * is not a built-in name) — it is never the removal criterion. Only call this\n * when `keep` is the COMPLETE set of agents that should live in `agentsDir`.\n */\nexport async function pruneStaleCompiledAgents(\n  agentsDir: string,\n  keep: ReadonlySet<AgentName>,\n  codec: AgentCodec = CLAUDE_AGENTS,\n): Promise<void> {\n  // A non-built-in basename is a hand-authored agent — always preserved.\n  const isStaleCompiledAgent = (file: string): boolean => {\n    const name = path.basename(file, codec.extension);\n    return isAgentName(name) && !keep.has(name);\n  };\n\n  const files = await listAgentFilesOf(agentsDir, codec);\n  await Promise.all(\n    files.filter(isStaleCompiledAgent).map((file) => remove(path.join(agentsDir, file))),\n  );\n}\n","import { partition } from \"remeda\";\nimport { writeCompiledAgentsByScope, type AgentWriteOutcome } from \"./write-compiled-agents\";\nimport { listCompiledAgentNames } from \"./list-compiled-agents\";\nimport path from \"path\";\n\nimport { getErrorMessage } from \"../../utils/errors\";\nimport type {\n  AgentDefinition,\n  AgentName,\n  CompileAgentConfig,\n  CompileConfig,\n  ProjectConfig,\n  SkillDefinitionMap,\n  SkillId,\n  SkillScope,\n} from \"../../types\";\n\nimport { buildCompileAgents } from \"../installation/local-installer\";\nimport { ensureDir } from \"../../utils/fs\";\nimport { verbose } from \"../../utils/logger\";\nimport { typedEntries, typedFromEntries, typedKeys } from \"../../utils/typed-object\";\nimport { createLiquidEngine } from \"../compiler\";\nimport { loadProjectConfig, effectivelyExcludedSkillIds } from \"../configuration\";\nimport { loadAllAgents, loadProjectAgents } from \"../loading\";\nimport { getPluginAgentsDir } from \"../plugins\";\nimport { discoverAllPluginSkills } from \"../plugins/plugin-discovery\";\nimport { resolveAgents } from \"../resolver\";\n\nexport type RecompileAgentsOptions = {\n  pluginDir: string;\n  sourcePath: string;\n  agents?: AgentName[];\n  skills?: SkillDefinitionMap;\n  projectDir?: string;\n  outputDir?: string;\n  /** When provided, routes agents by scope: global agents to ~/.claude/agents/, project agents to outputDir */\n  agentScopeMap?: Map<AgentName, SkillScope>;\n};\n\nexport type RecompileAgentsResult = {\n  compiled: AgentName[];\n  /**\n   * The subset of `compiled` whose file this pass actually wrote. `compiled` is\n   * every agent that came through the pass with a correct file at the end of it;\n   * `rewritten` is the ones whose content moved, so `compiled minus rewritten` is\n   * the count a summary reports as unchanged.\n   */\n  rewritten: AgentName[];\n  failed: AgentName[];\n  warnings: string[];\n};\n\nasync function getExistingAgentNames(pluginDir: string): Promise<AgentName[]> {\n  return listCompiledAgentNames(getPluginAgentsDir(pluginDir));\n}\n\ntype ResolveAgentNamesParams = {\n  specifiedAgents?: AgentName[];\n  projectConfig: ProjectConfig | null;\n  allAgents: Partial<Record<AgentName, AgentDefinition>>;\n  outputDir?: string;\n  pluginDir: string;\n};\n\nasync function resolveAgentNames(params: ResolveAgentNamesParams): Promise<AgentName[]> {\n  const { specifiedAgents, projectConfig, allAgents, outputDir, pluginDir } = params;\n\n  if (specifiedAgents) {\n    return specifiedAgents;\n  }\n\n  // A present config is authoritative over its agent roster — even when empty.\n  // `agents: []` means \"no agents\", so it must NOT fall through to the\n  // all-agents branch below; that branch exists only for the config-LESS case.\n  if (projectConfig) {\n    const agentNames = projectConfig.agents.map((a) => a.name);\n    verbose(`Using agents from config: ${agentNames.join(\", \")}`);\n    return agentNames;\n  }\n\n  if (outputDir) {\n    const names = typedKeys<AgentName>(allAgents);\n    verbose(`Using all available agents from source: ${names.join(\", \")}`);\n    return names;\n  }\n\n  return getExistingAgentNames(pluginDir);\n}\n\n/** Splits write outcomes into the recompile result; logs each success at verbose level. */\nfunction buildRecompileResult(\n  outcomes: AgentWriteOutcome[],\n  priorWarnings: string[],\n): RecompileAgentsResult {\n  const [succeeded, failedOutcomes] = partition(\n    outcomes,\n    (outcome): outcome is Extract<AgentWriteOutcome, { ok: true }> => outcome.ok,\n  );\n  succeeded.forEach((outcome) =>\n    verbose(\n      `  ${outcome.rewritten ? \"Rewrote\" : \"Unchanged\"}: ${outcome.name} (${outcome.scope} -> ${outcome.targetDir})`,\n    ),\n  );\n  return {\n    compiled: succeeded.map((outcome) => outcome.name),\n    rewritten: succeeded.filter((outcome) => outcome.rewritten).map((outcome) => outcome.name),\n    failed: failedOutcomes.map((outcome) => outcome.name),\n    warnings: [\n      ...priorWarnings,\n      ...failedOutcomes.map(\n        (outcome) => `Failed to compile ${outcome.name}: ${getErrorMessage(outcome.error)}`,\n      ),\n    ],\n  };\n}\n\nexport function filterExcludedEntries(config: ProjectConfig): ProjectConfig {\n  const excludedIds = effectivelyExcludedSkillIds(config.skills);\n  const activeSkills = config.skills.filter((s) => !s.excluded);\n  const activeAgents = config.agents.filter((a) => !a.excluded);\n\n  // A config with no stack keeps none — the key stays absent rather than becoming an\n  // explicit `undefined`.\n  const filteredStack =\n    config.stack === undefined\n      ? {}\n      : { stack: withoutExcludedAssignments(config.stack, excludedIds) };\n\n  return { ...config, skills: activeSkills, agents: activeAgents, ...filteredStack };\n}\n\n/**\n * The stack with every excluded skill's assignment taken out. Each agent and category keeps its\n * key, even where that leaves a category with no assignments.\n */\nexport function withoutExcludedAssignments(\n  stack: NonNullable<ProjectConfig[\"stack\"]>,\n  excludedIds: ReadonlySet<SkillId>,\n): NonNullable<ProjectConfig[\"stack\"]> {\n  return Object.fromEntries(\n    typedEntries(stack).map(([agentName, agentStack]) => [\n      agentName,\n      Object.fromEntries(\n        typedEntries(agentStack).map(([category, assignments]) => [\n          category,\n          assignments.filter((assignment) => !excludedIds.has(assignment.id)),\n        ]),\n      ),\n    ]),\n  );\n}\n\nexport async function recompileAgents(\n  options: RecompileAgentsOptions,\n): Promise<RecompileAgentsResult> {\n  const { pluginDir, sourcePath, skills: providedSkills, projectDir, outputDir } = options;\n\n  const configDir = projectDir ?? pluginDir;\n  const loadedConfig = await loadProjectConfig(configDir);\n  const projectConfig = loadedConfig?.config ?? null;\n\n  // Filter excluded entries once at the entry point — callees receive clean data\n  const filteredConfig = projectConfig ? filterExcludedEntries(projectConfig) : null;\n\n  const builtinAgents = await loadAllAgents(sourcePath);\n  const projectAgents = projectDir ? await loadProjectAgents(projectDir) : {};\n\n  // Priority: project agents > built-in agents\n  const allAgents: Partial<Record<AgentName, AgentDefinition>> = {\n    ...builtinAgents,\n    ...projectAgents,\n  };\n\n  const agentNames = await resolveAgentNames({\n    ...(options.agents !== undefined && { specifiedAgents: options.agents }),\n    projectConfig: filteredConfig,\n    allAgents,\n    ...(outputDir !== undefined && { outputDir }),\n    pluginDir,\n  });\n\n  // An empty pass has nothing to say: every caller reports one off `compiled`, and a warning here\n  // only ever surfaced merged into the OTHER scope's failure report, beside agents that compiled.\n  if (agentNames.length === 0) {\n    return { compiled: [], rewritten: [], failed: [], warnings: [] };\n  }\n\n  verbose(`Recompiling ${agentNames.length} agents in ${outputDir ?? pluginDir}`);\n\n  // When skills are not provided, discover from all plugin directories.\n  const pluginSkills: SkillDefinitionMap =\n    providedSkills ?? (await discoverAllPluginSkills(projectDir ?? pluginDir));\n\n  const { configAgents, missingWarnings } = compileEntriesFor(\n    agentNames,\n    filteredConfig,\n    allAgents,\n  );\n\n  const compileConfig: CompileConfig = {\n    name: filteredConfig?.name || path.basename(pluginDir),\n    description: filteredConfig?.description || \"Recompiled plugin\",\n    agents: configAgents,\n  };\n\n  const engine = await createLiquidEngine(projectDir);\n  const resolvedAgents = await resolveAgents(allAgents, pluginSkills, compileConfig, sourcePath);\n\n  const agentsDir = outputDir ?? getPluginAgentsDir(pluginDir);\n  await ensureDir(agentsDir);\n\n  const outcomes = await writeCompiledAgentsByScope({\n    resolvedAgents,\n    sourcePath,\n    engine,\n    projectAgentsDir: agentsDir,\n    // The same root this pass loaded its config from, so the provider that decides the FORMAT\n    // and the provider that decided the configuration are read off one installation.\n    projectDir: configDir,\n    ...(options.agentScopeMap !== undefined && { agentScopeMap: options.agentScopeMap }),\n  });\n  return buildRecompileResult(outcomes, missingWarnings);\n}\n\n/**\n * The compile entries for exactly the agents this pass compiles, and a warning for each named\n * agent that neither the config nor the source defines.\n *\n * `buildCompileAgents` returns entries for ALL agents in the config, but when scopeFilter is\n * active, we only want the agents matching that scope. Without this restriction, a project pass\n * would compile global agents without their stack (since the project config omits global agent\n * stack entries) and overwrite correctly compiled global agent files.\n */\nfunction compileEntriesFor(\n  agentNames: AgentName[],\n  config: ProjectConfig | null,\n  allAgents: Partial<Record<AgentName, AgentDefinition>>,\n): { configAgents: Partial<Record<AgentName, CompileAgentConfig>>; missingWarnings: string[] } {\n  const allConfigAgents = config ? buildCompileAgents(config, allAgents) : {};\n\n  const [knownAgents, missingAgents] = partition(agentNames, (name) =>\n    Boolean(allConfigAgents[name] || allAgents[name]),\n  );\n\n  return {\n    configAgents: typedFromEntries<AgentName, CompileAgentConfig>(\n      knownAgents.map((name) => [name, allConfigAgents[name] ?? {}]),\n    ),\n    missingWarnings: missingAgents.map((name) => `Agent \"${name}\" not found in source definitions`),\n  };\n}\n","import os from \"os\";\nimport path from \"path\";\nimport type { Liquid } from \"liquidjs\";\nimport { compileAgentForHost } from \"../compiler.js\";\nimport { resolveInstallPaths } from \"../installation/install-base-dir.js\";\nimport { agentCodec, hostCompilesAgent, providerInUse } from \"../installation/install-layout.js\";\nimport { writeFile, fileExists, readFile } from \"../../utils/fs.js\";\nimport { typedEntries } from \"../../utils/typed-object.js\";\nimport type { Provider } from \"../../consts.js\";\nimport type { AgentConfig, AgentName, SkillScope } from \"../../types/index.js\";\n\nexport type AgentWriteOutcome =\n  | {\n      name: AgentName;\n      ok: true;\n      scope: SkillScope;\n      targetDir: string;\n      /**\n       * Whether this pass actually wrote the file. False means the compiled output\n       * matched what was already on disk, so nothing was written — which is what\n       * lets a recompile summary tell a real one from a no-op instead of counting\n       * the roster it walked.\n       */\n      rewritten: boolean;\n    }\n  | { name: AgentName; ok: false; error: unknown };\n\n/**\n * Whether the target already holds exactly this content, making a write a no-op.\n *\n * Skipping that write is what gives \"unchanged\" a meaning a caller can check: an\n * agent reported unchanged keeps its mtime, and an mtime is the only trace a\n * rewrite-with-identical-bytes leaves anywhere.\n */\nasync function holdsExactly(filePath: string, content: string): Promise<boolean> {\n  return (await fileExists(filePath)) && (await readFile(filePath)) === content;\n}\n\n/**\n * Where an agent goes when `agentScopeMap` has nothing to say about it — either because the caller\n * passed no map at all or because this agent is not in the one it passed (a hand-authored agent\n * under `.claude/agents/` has no config row).\n *\n * This is a ROUTING answer, not a selection default: `\"project\"` here means \"the directory the\n * caller named in `projectAgentsDir`\", which for an unrouted write is the only defensible target.\n * It is deliberately NOT `DEFAULT_SELECTION_OPTIONS.scope` from `@workspace/matrix` — that constant\n * says what an untouched *pick* installs as, and adopting it here would relocate the agents of every\n * caller that never asked for global routing into the user's `~/.claude/agents`.\n */\nconst UNROUTED_AGENT_SCOPE: SkillScope = \"project\";\n\n/**\n * Compiles each resolved agent and writes it to its scope's agents directory:\n * global agents to `~/.claude/agents/`, project agents to `projectAgentsDir`.\n * Per-agent failures are collected as outcomes — callers own the policy\n * (recompile reports and continues; install hard-errors).\n *\n * Neither directory is created up front. `writeFile` makes a target's parent on\n * the way past, so a directory appears exactly when an agent routes into it —\n * which is what keeps a wholly project-scoped pass from leaving an empty\n * `~/.claude/agents/` behind in a home that has no global install.\n */\nexport async function writeCompiledAgentsByScope(params: {\n  resolvedAgents: Partial<Record<AgentName, AgentConfig>>;\n  sourcePath: string;\n  engine: Liquid;\n  projectAgentsDir: string;\n  /** The root whose folder says which host the PROJECT scope's sub-agents are written for. */\n  projectDir: string;\n  agentScopeMap?: Map<AgentName, SkillScope>;\n}): Promise<AgentWriteOutcome[]> {\n  const hosts: Record<SkillScope, AgentHost> = {\n    // Each scope reads its OWN root, the way `resolveInstallPaths` reads one beside this: a\n    // project on Codex under a global on Claude is an arrangement this product allows, and one\n    // provider answered for both scopes is how a pass writes the wrong format into one of them.\n    global: {\n      provider: providerInUse(os.homedir()),\n      agentsDir: resolveInstallPaths(os.homedir(), \"global\").agentsDir,\n    },\n    project: { provider: providerInUse(params.projectDir), agentsDir: params.projectAgentsDir },\n  };\n\n  const outcomes: AgentWriteOutcome[] = [];\n  for (const [name, agent] of typedEntries<AgentName, AgentConfig>(params.resolvedAgents)) {\n    const scope = params.agentScopeMap?.get(name) ?? UNROUTED_AGENT_SCOPE;\n    const host = hosts[scope];\n\n    // Before the render, and it produces NO outcome: a sub-agent this host does not carry was\n    // not compiled and did not fail, so counting it either way would make a deliberate omission\n    // read as a result. The one line the user is owed is the command's, once per run.\n    if (!hostCompilesAgent(host.provider, name)) continue;\n\n    outcomes.push(await writeOneAgent({ ...params, name, agent, scope, host }));\n  }\n  return outcomes;\n}\n\n/**\n * One sub-agent rendered for its host and written where that host reads it.\n *\n * The failure is RETURNED rather than thrown, because the policy belongs to the caller: recompile\n * reports and continues, install hard-errors. A pass that stopped at the first bad sub-agent would\n * make that decision for both of them.\n */\nasync function writeOneAgent(params: {\n  name: AgentName;\n  agent: AgentConfig;\n  scope: SkillScope;\n  host: AgentHost;\n  sourcePath: string;\n  engine: Liquid;\n}): Promise<AgentWriteOutcome> {\n  const { name, scope, host } = params;\n\n  try {\n    const output = await compileAgentForHost(\n      host.provider,\n      name,\n      params.agent,\n      params.sourcePath,\n      params.engine,\n    );\n    const targetPath = path.join(host.agentsDir, fileNameFor(name, host.provider));\n    const rewritten = !(await holdsExactly(targetPath, output));\n    if (rewritten) await writeFile(targetPath, output);\n\n    return { name, ok: true, scope, targetDir: host.agentsDir, rewritten };\n  } catch (error) {\n    return { name, ok: false, error };\n  }\n}\n\n/** Where one scope's compiled sub-agents go, and in whose format. */\ntype AgentHost = { provider: Provider; agentsDir: string };\n\n/**\n * The file one compiled sub-agent is written to, extension included.\n *\n * The extension comes from {@link agentCodec} rather than from a literal here, because the defect\n * this whole funnel exists against is `web-developer.md` written into `<project>/.codex/agents/`\n * by a pass that then reports success: Codex ignores such a file, nothing recognises it as ours\n * again, and the run exits 0.\n */\nfunction fileNameFor(name: AgentName, provider: Provider): string {\n  return `${name}${agentCodec(provider).extension}`;\n}\n","import { Liquid } from \"liquidjs\";\nimport path from \"path\";\nimport {\n  buildAgentTemplateContext,\n  pluginRefFor,\n  renderAgent,\n  renderAgentBody,\n  renderAgentRoleToml,\n  type AgentFiles,\n} from \"@workspace/compile/agent-source\";\nimport { readFile, readFileOptional, directoryExists } from \"../utils/fs\";\nimport { verbose } from \"../utils/logger\";\nimport {\n  CLAUDE_DIR,\n  DIRS,\n  PROJECT_ROOT,\n  STANDARD_FILES,\n  STANDARD_DIRS,\n  type Provider,\n} from \"../consts\";\nimport { providerInUse, sourceFolderInUse, sourceFolderName } from \"./installation/install-layout\";\nimport { cliVersion } from \"./agents/agent-provenance\";\nimport \"./compile-seat.js\";\nimport type { AgentConfig, AgentName } from \"../types\";\n\n/**\n * What survives here is the half of a compile that reads the machine: the five `readFile`s that\n * fetch an agent's partials off disk, and the layered template roots a project can override. The\n * rendering itself — the template context, the injection sanitiser and the provenance stamp — is\n * `@workspace/compile/agent-source`, so the editor's output preview draws the bytes this writes\n * rather than a second implementation of them.\n */\nexport {\n  buildAgentTemplateContext,\n  sanitizeCompiledAgentData,\n  sanitizeLiquidSyntax,\n} from \"@workspace/compile/agent-source\";\n\nasync function readAgentFiles(\n  name: AgentName,\n  agent: AgentConfig,\n  projectRoot: string,\n): Promise<AgentFiles> {\n  const agentSourceRoot = agent.sourceRoot || projectRoot;\n  const agentBaseDir = agent.agentBaseDir || DIRS.agents;\n  const agentPath = agent.path || name;\n  const agentDir = path.join(agentSourceRoot, agentBaseDir, agentPath);\n\n  const identity = await readFile(path.join(agentDir, STANDARD_FILES.IDENTITY_MD));\n  const playbook = await readFile(path.join(agentDir, STANDARD_FILES.PLAYBOOK_MD));\n  const criticalRequirementsTop = await readFileOptional(\n    path.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),\n    \"\",\n  );\n  const criticalReminders = await readFileOptional(\n    path.join(agentDir, STANDARD_FILES.CRITICAL_REMINDERS_MD),\n    \"\",\n  );\n\n  const category = agentPath.split(\"/\")[0] || name;\n  const categoryDir = path.join(agentSourceRoot, agentBaseDir, category);\n  const output = await readOutputPartial(agentDir, categoryDir);\n\n  return { identity, playbook, output, criticalRequirementsTop, criticalReminders };\n}\n\n/** The agent's own `output.md`, or its category's where the agent's is absent or empty. */\nasync function readOutputPartial(agentDir: string, categoryDir: string): Promise<string> {\n  const own = await readFileOptional(path.join(agentDir, STANDARD_FILES.OUTPUT_MD), \"\");\n  if (own) return own;\n  return readFileOptional(path.join(categoryDir, STANDARD_FILES.OUTPUT_MD), \"\");\n}\n\n/**\n * Creates a Liquid template engine with a layered template root hierarchy.\n *\n * Template resolution order (first match wins):\n * 1. Project-local templates: `agents/_templates/` inside the project's source folder,\n *    `.agents-inc/<provider>/`, resolved by `sourceFolderInUse`\n * 2. Legacy templates: `{projectDir}/.claude/templates/`\n * 3. Built-in templates: `{PROJECT_ROOT}/src/agents/_templates/`\n *\n * The browser-side twin is `createEngineFromTemplates` in `@workspace/compile/engine`, which\n * builds the same engine over the vendored corpus instead of over directories. Every option\n * below is duplicated there, because a render that resolved filters or variables differently\n * would produce a different file from the same data.\n *\n * `globals.sourceFolder` is what makes a compiled agent's own text install-specific. A partial is\n * never rendered through this engine — it is prose, inlined verbatim — so `renderAgent` asks the\n * engine for that global and substitutes the one opted-in token itself, which is how\n * `agent-summoner` names the folder THIS project keeps its source in rather than a literal that is\n * wrong on every install of the other layout.\n *\n * @param projectDir - Optional project directory for local template overrides\n * @returns Configured Liquid engine with `.liquid` extension and strict filters\n */\nexport async function createLiquidEngine(projectDir?: string): Promise<Liquid> {\n  const roots: string[] = [];\n  // One read for both answers below: the templates this install overrides with, and the folder\n  // name a compiled `agent-summoner` is told to author into, have to name one installation.\n  const provider = providerInUse(projectDir);\n\n  if (projectDir) {\n    const srcTemplatesDir = path.join(\n      sourceFolderInUse(projectDir, provider).dir,\n      STANDARD_DIRS.AGENTS,\n      path.basename(DIRS.templates),\n    );\n    if (await directoryExists(srcTemplatesDir)) {\n      roots.push(srcTemplatesDir);\n      verbose(`Using local templates from: ${srcTemplatesDir}`);\n    }\n\n    const legacyTemplatesDir = path.join(projectDir, CLAUDE_DIR, STANDARD_DIRS.TEMPLATES);\n    if (await directoryExists(legacyTemplatesDir)) {\n      roots.push(legacyTemplatesDir);\n      verbose(`Using legacy templates from: ${legacyTemplatesDir}`);\n    }\n  }\n\n  roots.push(path.join(PROJECT_ROOT, DIRS.templates));\n\n  return new Liquid({\n    root: roots,\n    extname: \".liquid\",\n    strictVariables: false,\n    strictFilters: true,\n    globals: { sourceFolder: sourceFolderName(projectDir, provider) },\n  });\n}\n\n/**\n * One resolved sub-agent as the file `provider`'s host actually reads.\n *\n * **The two hosts share every byte of the prose and disagree about everything around it.** Claude\n * reads markdown under a frontmatter block; Codex reads an agent ROLE DEFINITION — TOML, three\n * required keys, and a deserializer that drops the WHOLE file on one unlisted key. So the split is\n * at the RENDER and not at the data: both start from the same\n * {@link buildAgentTemplateContext} context, and `renderAgentBody` is by construction the tail of\n * `renderAgent`, which is what makes a Codex sub-agent's instructions its Claude twin's byte for\n * byte.\n *\n * Nothing here decides WHICH sub-agents a host gets — `hostCompilesAgent` answers that, before the\n * write pass reaches this — and nothing here decides where the file goes.\n */\nexport async function compileAgentForHost(\n  provider: Provider,\n  name: AgentName,\n  agent: AgentConfig,\n  fallbackRoot: string,\n  engine: Liquid,\n): Promise<string> {\n  verbose(`Compiling agent: ${name} (${provider})`);\n\n  const files = await readAgentFiles(name, agent, fallbackRoot);\n\n  // Per-skill pluginRef attachment. Each skill's own `source` decides\n  // whether it renders as `${id}:${id}` (plugin-installed) or bare id (ejected).\n  // This correctly handles mixed-mode agents where some skills are plugin and\n  // others are ejected. Missing `source` (user-authored local skills with no\n  // SkillConfig entry) falls through to bare id — the expected case, not a\n  // silent fallback.\n  const data = buildAgentTemplateContext(name, agent, files, (skill) => ({\n    ...skill,\n    ...pluginRefFor(skill),\n  }));\n  const version = await cliVersion();\n\n  switch (provider) {\n    case \"claude\":\n      return renderAgent(engine, data, version);\n    case \"codex\":\n      return renderAgentRoleToml(agent, await renderAgentBody(engine, data, version));\n    default: {\n      const _exhaustive: never = provider;\n      return _exhaustive;\n    }\n  }\n}\n","import path from \"path\";\nimport { z } from \"zod\";\n\nimport { PROJECT_ROOT, STANDARD_FILES } from \"../../consts\";\nimport { readFile } from \"../../utils/fs\";\n\n/** The one field the marker needs from this CLI's own manifest. */\nconst ownPackageJsonSchema = z.object({ version: z.string().min(1) });\n\n/**\n * The provenance marker every compiled agent carries lives in `@workspace/compile/agent-source`,\n * beside the renderer that stamps it — the editor's output preview draws the same first body line\n * and must not compute it a second way. What stays here is the half that reads this CLI's own\n * manifest, which a browser has no equivalent of.\n */\nexport {\n  hasProvenanceMarker,\n  provenanceMarker,\n  stampProvenanceMarker,\n} from \"@workspace/compile/agent-source\";\n\nlet ownVersion: Promise<string> | undefined;\n\n/**\n * This CLI's own published version, read once per process from the package manifest beside\n * the code — the same `PROJECT_ROOT` the bundled agent partials and templates resolve from.\n *\n * It reaches a compiled agent as the `version` argument of `renderAgent`, which hands it to the\n * template as `generatorVersion`; `agent.liquid` renders it in the trailing `<system-reminder>`\n * block. Deliberately not the provenance marker above it — that line's bytes are constant across\n * releases, so a version bump no longer rewrites the first cacheable byte of every compiled agent.\n */\nexport function cliVersion(): Promise<string> {\n  ownVersion ??= readOwnVersion();\n  return ownVersion;\n}\n\nasync function readOwnVersion(): Promise<string> {\n  const manifestPath = path.join(PROJECT_ROOT, STANDARD_FILES.PACKAGE_JSON);\n  const raw: unknown = JSON.parse(await readFile(manifestPath));\n\n  const parsed = ownPackageJsonSchema.safeParse(raw);\n  if (!parsed.success) {\n    throw new Error(`Could not read this CLI's own version from ${manifestPath}`);\n  }\n  return parsed.data.version;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,UAAU;AACjB,SAAS,iBAAiB;AAa1B,IAAM,gBAAgB,WAAW,QAAQ;AAWzC,eAAsB,iBAAiB,WAAsC;AAC3E,SAAO,iBAAiB,WAAW,aAAa;AAClD;AAGA,eAAsB,iBAAiB,WAAmB,OAAsC;AAC9F,SAAO,KAAK,MAAM,UAAU,SAAS;AACvC;AAUA,eAAsB,wBACpB,WACA,QAAoB,eACW;AAC/B,QAAM,QAAQ,MAAM,iBAAiB,WAAW,KAAK;AACrD,QAAM,aAAa,MAAM,QAAQ;AAAA,IAC/B,MAAM,IAAI,CAAC,SAAS,oBAAoB,WAAW,MAAM,KAAK,CAAC;AAAA,EACjE;AACA,QAAM,CAAC,QAAQ,QAAQ,IAAI,UAAU,YAAY,CAAC,UAAU,MAAM,YAAY;AAE9E,SAAO,EAAE,QAAQ,OAAO,IAAI,SAAS,GAAG,UAAU,SAAS,IAAI,SAAS,EAAE;AAC5E;AAIA,eAAe,oBACb,WACA,MACA,OAC0B;AAC1B,QAAM,UAAU,MAAM,iBAAiB,KAAK,KAAK,WAAW,IAAI,CAAC;AACjE,SAAO,EAAE,MAAM,KAAK,SAAS,MAAM,MAAM,SAAS,GAAG,cAAc,MAAM,UAAU,OAAO,EAAE;AAC9F;AAEA,SAAS,UAAU,OAAgC;AACjD,SAAO,MAAM;AACf;AAGA,eAAsB,uBAAuB,WAAyC;AACpF,QAAM,QAAQ,MAAM,iBAAiB,SAAS;AAG9C,SAAO,MAAM,IAAI,CAAC,MAAM,KAAK,SAAS,GAAG,KAAK,CAAc;AAC9D;AASA,eAAsB,yBACpB,WACA,MACA,QAAoB,eACL;AAEf,QAAM,uBAAuB,CAAC,SAA0B;AACtD,UAAM,OAAO,KAAK,SAAS,MAAM,MAAM,SAAS;AAChD,WAAO,YAAY,IAAI,KAAK,CAAC,KAAK,IAAI,IAAI;AAAA,EAC5C;AAEA,QAAM,QAAQ,MAAM,iBAAiB,WAAW,KAAK;AACrD,QAAM,QAAQ;AAAA,IACZ,MAAM,OAAO,oBAAoB,EAAE,IAAI,CAAC,SAAS,OAAO,KAAK,KAAK,WAAW,IAAI,CAAC,CAAC;AAAA,EACrF;AACF;;;ACpGA,SAAS,aAAAA,kBAAiB;;;ACA1B,OAAO,QAAQ;AACf,OAAOC,WAAU;;;ACDjB,SAAS,cAAc;AACvB,OAAOC,WAAU;;;ACDjB,OAAOC,WAAU;AACjB,SAAS,SAAS;AAMlB,IAAM,uBAAuB,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC;AAcpE,IAAI;AAWG,SAAS,aAA8B;AAC5C,iBAAe,eAAe;AAC9B,SAAO;AACT;AAEA,eAAe,iBAAkC;AAC/C,QAAM,eAAeC,MAAK,KAAK,cAAc,eAAe,YAAY;AACxE,QAAM,MAAe,KAAK,MAAM,MAAM,SAAS,YAAY,CAAC;AAE5D,QAAM,SAAS,qBAAqB,UAAU,GAAG;AACjD,MAAI,CAAC,OAAO,SAAS;AACnB,UAAM,IAAI,MAAM,8CAA8C,YAAY,EAAE;AAAA,EAC9E;AACA,SAAO,OAAO,KAAK;AACrB;;;ADRA,eAAe,eACb,MACA,OACA,aACqB;AACrB,QAAM,kBAAkB,MAAM,cAAc;AAC5C,QAAM,eAAe,MAAM,gBAAgB,KAAK;AAChD,QAAM,YAAY,MAAM,QAAQ;AAChC,QAAM,WAAWC,MAAK,KAAK,iBAAiB,cAAc,SAAS;AAEnE,QAAM,WAAW,MAAM,SAASA,MAAK,KAAK,UAAU,eAAe,WAAW,CAAC;AAC/E,QAAM,WAAW,MAAM,SAASA,MAAK,KAAK,UAAU,eAAe,WAAW,CAAC;AAC/E,QAAM,0BAA0B,MAAM;AAAA,IACpCA,MAAK,KAAK,UAAU,eAAe,wBAAwB;AAAA,IAC3D;AAAA,EACF;AACA,QAAM,oBAAoB,MAAM;AAAA,IAC9BA,MAAK,KAAK,UAAU,eAAe,qBAAqB;AAAA,IACxD;AAAA,EACF;AAEA,QAAM,WAAW,UAAU,MAAM,GAAG,EAAE,CAAC,KAAK;AAC5C,QAAM,cAAcA,MAAK,KAAK,iBAAiB,cAAc,QAAQ;AACrE,QAAM,SAAS,MAAM,kBAAkB,UAAU,WAAW;AAE5D,SAAO,EAAE,UAAU,UAAU,QAAQ,yBAAyB,kBAAkB;AAClF;AAGA,eAAe,kBAAkB,UAAkB,aAAsC;AACvF,QAAM,MAAM,MAAM,iBAAiBA,MAAK,KAAK,UAAU,eAAe,SAAS,GAAG,EAAE;AACpF,MAAI,IAAK,QAAO;AAChB,SAAO,iBAAiBA,MAAK,KAAK,aAAa,eAAe,SAAS,GAAG,EAAE;AAC9E;AAyBA,eAAsB,mBAAmB,YAAsC;AAC7E,QAAM,QAAkB,CAAC;AAGzB,QAAM,WAAW,cAAc,UAAU;AAEzC,MAAI,YAAY;AACd,UAAM,kBAAkBA,MAAK;AAAA,MAC3B,kBAAkB,YAAY,QAAQ,EAAE;AAAA,MACxC,cAAc;AAAA,MACdA,MAAK,SAAS,KAAK,SAAS;AAAA,IAC9B;AACA,QAAI,MAAM,gBAAgB,eAAe,GAAG;AAC1C,YAAM,KAAK,eAAe;AAC1B,cAAQ,+BAA+B,eAAe,EAAE;AAAA,IAC1D;AAEA,UAAM,qBAAqBA,MAAK,KAAK,YAAY,YAAY,cAAc,SAAS;AACpF,QAAI,MAAM,gBAAgB,kBAAkB,GAAG;AAC7C,YAAM,KAAK,kBAAkB;AAC7B,cAAQ,gCAAgC,kBAAkB,EAAE;AAAA,IAC9D;AAAA,EACF;AAEA,QAAM,KAAKA,MAAK,KAAK,cAAc,KAAK,SAAS,CAAC;AAElD,SAAO,IAAI,OAAO;AAAA,IAChB,MAAM;AAAA,IACN,SAAS;AAAA,IACT,iBAAiB;AAAA,IACjB,eAAe;AAAA,IACf,SAAS,EAAE,cAAc,iBAAiB,YAAY,QAAQ,EAAE;AAAA,EAClE,CAAC;AACH;AAgBA,eAAsB,oBACpB,UACA,MACA,OACA,cACA,QACiB;AACjB,UAAQ,oBAAoB,IAAI,KAAK,QAAQ,GAAG;AAEhD,QAAM,QAAQ,MAAM,eAAe,MAAM,OAAO,YAAY;AAQ5D,QAAM,OAAO,0BAA0B,MAAM,OAAO,OAAO,CAAC,WAAW;AAAA,IACrE,GAAG;AAAA,IACH,GAAG,aAAa,KAAK;AAAA,EACvB,EAAE;AACF,QAAM,UAAU,MAAM,WAAW;AAEjC,UAAQ,UAAU;AAAA,IAChB,KAAK;AACH,aAAO,YAAY,QAAQ,MAAM,OAAO;AAAA,IAC1C,KAAK;AACH,aAAO,oBAAoB,OAAO,MAAM,gBAAgB,QAAQ,MAAM,OAAO,CAAC;AAAA,IAChF,SAAS;AACP,YAAM,cAAqB;AAC3B,aAAO;AAAA,IACT;AAAA,EACF;AACF;;;ADhJA,eAAe,aAAa,UAAkB,SAAmC;AAC/E,SAAQ,MAAM,WAAW,QAAQ,KAAO,MAAM,SAAS,QAAQ,MAAO;AACxE;AAaA,IAAM,uBAAmC;AAazC,eAAsB,2BAA2B,QAQhB;AAC/B,QAAM,QAAuC;AAAA;AAAA;AAAA;AAAA,IAI3C,QAAQ;AAAA,MACN,UAAU,cAAc,GAAG,QAAQ,CAAC;AAAA,MACpC,WAAW,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,EAAE;AAAA,IACzD;AAAA,IACA,SAAS,EAAE,UAAU,cAAc,OAAO,UAAU,GAAG,WAAW,OAAO,iBAAiB;AAAA,EAC5F;AAEA,QAAM,WAAgC,CAAC;AACvC,aAAW,CAAC,MAAM,KAAK,KAAK,aAAqC,OAAO,cAAc,GAAG;AACvF,UAAM,QAAQ,OAAO,eAAe,IAAI,IAAI,KAAK;AACjD,UAAM,OAAO,MAAM,KAAK;AAKxB,QAAI,CAAC,kBAAkB,KAAK,UAAU,IAAI,EAAG;AAE7C,aAAS,KAAK,MAAM,cAAc,EAAE,GAAG,QAAQ,MAAM,OAAO,OAAO,KAAK,CAAC,CAAC;AAAA,EAC5E;AACA,SAAO;AACT;AASA,eAAe,cAAc,QAOE;AAC7B,QAAM,EAAE,MAAM,OAAO,KAAK,IAAI;AAE9B,MAAI;AACF,UAAM,SAAS,MAAM;AAAA,MACnB,KAAK;AAAA,MACL;AAAA,MACA,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,IACT;AACA,UAAM,aAAaC,MAAK,KAAK,KAAK,WAAW,YAAY,MAAM,KAAK,QAAQ,CAAC;AAC7E,UAAM,YAAY,CAAE,MAAM,aAAa,YAAY,MAAM;AACzD,QAAI,UAAW,OAAM,UAAU,YAAY,MAAM;AAEjD,WAAO,EAAE,MAAM,IAAI,MAAM,OAAO,WAAW,KAAK,WAAW,UAAU;AAAA,EACvE,SAAS,OAAO;AACd,WAAO,EAAE,MAAM,IAAI,OAAO,MAAM;AAAA,EAClC;AACF;AAaA,SAAS,YAAY,MAAiB,UAA4B;AAChE,SAAO,GAAG,IAAI,GAAG,WAAW,QAAQ,EAAE,SAAS;AACjD;;;AD9IA,OAAOC,WAAU;AAiDjB,eAAe,sBAAsB,WAAyC;AAC5E,SAAO,uBAAuB,mBAAmB,SAAS,CAAC;AAC7D;AAUA,eAAe,kBAAkB,QAAuD;AACtF,QAAM,EAAE,iBAAiB,eAAe,WAAW,WAAW,UAAU,IAAI;AAE5E,MAAI,iBAAiB;AACnB,WAAO;AAAA,EACT;AAKA,MAAI,eAAe;AACjB,UAAM,aAAa,cAAc,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI;AACzD,YAAQ,6BAA6B,WAAW,KAAK,IAAI,CAAC,EAAE;AAC5D,WAAO;AAAA,EACT;AAEA,MAAI,WAAW;AACb,UAAM,QAAQ,UAAqB,SAAS;AAC5C,YAAQ,2CAA2C,MAAM,KAAK,IAAI,CAAC,EAAE;AACrE,WAAO;AAAA,EACT;AAEA,SAAO,sBAAsB,SAAS;AACxC;AAGA,SAAS,qBACP,UACA,eACuB;AACvB,QAAM,CAAC,WAAW,cAAc,IAAIC;AAAA,IAClC;AAAA,IACA,CAAC,YAAiE,QAAQ;AAAA,EAC5E;AACA,YAAU;AAAA,IAAQ,CAAC,YACjB;AAAA,MACE,KAAK,QAAQ,YAAY,YAAY,WAAW,KAAK,QAAQ,IAAI,KAAK,QAAQ,KAAK,OAAO,QAAQ,SAAS;AAAA,IAC7G;AAAA,EACF;AACA,SAAO;AAAA,IACL,UAAU,UAAU,IAAI,CAAC,YAAY,QAAQ,IAAI;AAAA,IACjD,WAAW,UAAU,OAAO,CAAC,YAAY,QAAQ,SAAS,EAAE,IAAI,CAAC,YAAY,QAAQ,IAAI;AAAA,IACzF,QAAQ,eAAe,IAAI,CAAC,YAAY,QAAQ,IAAI;AAAA,IACpD,UAAU;AAAA,MACR,GAAG;AAAA,MACH,GAAG,eAAe;AAAA,QAChB,CAAC,YAAY,qBAAqB,QAAQ,IAAI,KAAK,gBAAgB,QAAQ,KAAK,CAAC;AAAA,MACnF;AAAA,IACF;AAAA,EACF;AACF;AAEO,SAAS,sBAAsB,QAAsC;AAC1E,QAAM,cAAc,4BAA4B,OAAO,MAAM;AAC7D,QAAM,eAAe,OAAO,OAAO,OAAO,CAAC,MAAM,CAAC,EAAE,QAAQ;AAC5D,QAAM,eAAe,OAAO,OAAO,OAAO,CAAC,MAAM,CAAC,EAAE,QAAQ;AAI5D,QAAM,gBACJ,OAAO,UAAU,SACb,CAAC,IACD,EAAE,OAAO,2BAA2B,OAAO,OAAO,WAAW,EAAE;AAErE,SAAO,EAAE,GAAG,QAAQ,QAAQ,cAAc,QAAQ,cAAc,GAAG,cAAc;AACnF;AAMO,SAAS,2BACd,OACA,aACqC;AACrC,SAAO,OAAO;AAAA,IACZ,aAAa,KAAK,EAAE,IAAI,CAAC,CAACC,YAAW,UAAU,MAAM;AAAA,MACnDA;AAAA,MACA,OAAO;AAAA,QACL,aAAa,UAAU,EAAE,IAAI,CAAC,CAAC,UAAU,WAAW,MAAM;AAAA,UACxD;AAAA,UACA,YAAY,OAAO,CAAC,eAAe,CAAC,YAAY,IAAI,WAAW,EAAE,CAAC;AAAA,QACpE,CAAC;AAAA,MACH;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEA,eAAsB,gBACpB,SACgC;AAChC,QAAM,EAAE,WAAW,YAAY,QAAQ,gBAAgB,YAAY,UAAU,IAAI;AAEjF,QAAM,YAAY,cAAc;AAChC,QAAM,eAAe,MAAM,kBAAkB,SAAS;AACtD,QAAM,gBAAgB,cAAc,UAAU;AAG9C,QAAM,iBAAiB,gBAAgB,sBAAsB,aAAa,IAAI;AAE9E,QAAM,gBAAgB,MAAM,cAAc,UAAU;AACpD,QAAM,gBAAgB,aAAa,MAAM,kBAAkB,UAAU,IAAI,CAAC;AAG1E,QAAM,YAAyD;AAAA,IAC7D,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AAEA,QAAM,aAAa,MAAM,kBAAkB;AAAA,IACzC,GAAI,QAAQ,WAAW,UAAa,EAAE,iBAAiB,QAAQ,OAAO;AAAA,IACtE,eAAe;AAAA,IACf;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,IAC3C;AAAA,EACF,CAAC;AAID,MAAI,WAAW,WAAW,GAAG;AAC3B,WAAO,EAAE,UAAU,CAAC,GAAG,WAAW,CAAC,GAAG,QAAQ,CAAC,GAAG,UAAU,CAAC,EAAE;AAAA,EACjE;AAEA,UAAQ,eAAe,WAAW,MAAM,cAAc,aAAa,SAAS,EAAE;AAG9E,QAAM,eACJ,kBAAmB,MAAM,wBAAwB,cAAc,SAAS;AAE1E,QAAM,EAAE,cAAc,gBAAgB,IAAI;AAAA,IACxC;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,QAAM,gBAA+B;AAAA,IACnC,MAAM,gBAAgB,QAAQC,MAAK,SAAS,SAAS;AAAA,IACrD,aAAa,gBAAgB,eAAe;AAAA,IAC5C,QAAQ;AAAA,EACV;AAEA,QAAM,SAAS,MAAM,mBAAmB,UAAU;AAClD,QAAM,iBAAiB,MAAM,cAAc,WAAW,cAAc,eAAe,UAAU;AAE7F,QAAM,YAAY,aAAa,mBAAmB,SAAS;AAC3D,QAAM,UAAU,SAAS;AAEzB,QAAM,WAAW,MAAM,2BAA2B;AAAA,IAChD;AAAA,IACA;AAAA,IACA;AAAA,IACA,kBAAkB;AAAA;AAAA;AAAA,IAGlB,YAAY;AAAA,IACZ,GAAI,QAAQ,kBAAkB,UAAa,EAAE,eAAe,QAAQ,cAAc;AAAA,EACpF,CAAC;AACD,SAAO,qBAAqB,UAAU,eAAe;AACvD;AAWA,SAAS,kBACP,YACA,QACA,WAC6F;AAC7F,QAAM,kBAAkB,SAAS,mBAAmB,QAAQ,SAAS,IAAI,CAAC;AAE1E,QAAM,CAAC,aAAa,aAAa,IAAIF;AAAA,IAAU;AAAA,IAAY,CAAC,SAC1D,QAAQ,gBAAgB,IAAI,KAAK,UAAU,IAAI,CAAC;AAAA,EAClD;AAEA,SAAO;AAAA,IACL,cAAc;AAAA,MACZ,YAAY,IAAI,CAAC,SAAS,CAAC,MAAM,gBAAgB,IAAI,KAAK,CAAC,CAAC,CAAC;AAAA,IAC/D;AAAA,IACA,iBAAiB,cAAc,IAAI,CAAC,SAAS,UAAU,IAAI,mCAAmC;AAAA,EAChG;AACF;","names":["partition","path","path","path","path","path","path","path","partition","agentName","path"]}

package/dist/{chunk-RGYDFBCT.js → chunk-HHIYT3PI.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   Wizard
-} from "./chunk-ECURHW3T.js";
+} from "./chunk-WWIFNPJG.js";
 import {
   promptValue
-} from "./chunk-JCPANDNR.js";
+} from "./chunk-4AAOOAIN.js";
 import {
   hydrateWizardStore
-} from "./chunk-K5ITEA3I.js";
+} from "./chunk-7JNJ52CD.js";
 import {
   disableBuffering,
   drainBuffer,
   enableBuffering
-} from "./chunk-XPDVAJDH.js";
+} from "./chunk-A4KDXNOT.js";
 
 // src/cli/components/wizard/run-wizard-session.tsx
 import "react";
@@ -50,4 +50,4 @@ async function runWizardSession(options) {
 export {
   runWizardSession
 };
-//# sourceMappingURL=chunk-RGYDFBCT.js.map
+//# sourceMappingURL=chunk-HHIYT3PI.js.map