@open-mercato/cli 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/dist/lib/generators/extensions/agent-files.js

@@ -0,0 +1,913 @@
+import fs from "node:fs";
+import path from "node:path";
+import { countTokens } from "@open-mercato/shared/lib/ai/token-count";
+import { resolveStandaloneSourceMirrorBase } from "../scanner.js";
+const FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+const JSON_FENCE_RE = /```json\s*\n([\s\S]*?)\n```/;
+const LIST_KEYS = ["tools", "skills", "subAgents"];
+function stripQuotes(value) {
+  return value.trim().replace(/^['"]/, "").replace(/['"]$/, "").trim();
+}
+function parseInlineList(rawValue) {
+  return rawValue.replace(/^\[/, "").replace(/\]$/, "").split(",").map((entry) => stripQuotes(entry)).filter(Boolean);
+}
+function parseAgentMarkdown(raw) {
+  const match = FRONTMATTER_RE.exec(raw);
+  if (!match) return null;
+  const [, frontmatterBlock, body] = match;
+  const meta = { tools: [], skills: [], subAgents: [], instructions: body.trim() };
+  const lines = frontmatterBlock.split("\n");
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (!line.trim()) {
+      index += 1;
+      continue;
+    }
+    const lineMatch = /^([A-Za-z0-9_]+):\s*(.*)$/.exec(line);
+    if (!lineMatch) {
+      index += 1;
+      continue;
+    }
+    const key = lineMatch[1];
+    const rawValue = lineMatch[2].trim();
+    if (LIST_KEYS.includes(key)) {
+      const listKey = key;
+      if (rawValue.startsWith("[")) {
+        meta[listKey] = parseInlineList(rawValue);
+        index += 1;
+        continue;
+      }
+      const items = [];
+      index += 1;
+      while (index < lines.length && /^\s*-\s+/.test(lines[index])) {
+        items.push(stripQuotes(lines[index].replace(/^\s*-\s+/, "")));
+        index += 1;
+      }
+      meta[listKey] = items.filter(Boolean);
+      continue;
+    }
+    if (key === "maxSteps") {
+      const parsed = Number.parseInt(stripQuotes(rawValue), 10);
+      if (!Number.isNaN(parsed)) meta.maxSteps = parsed;
+      index += 1;
+      continue;
+    }
+    if (key === "id" || key === "label" || key === "description" || key === "provider" || key === "model") {
+      meta[key] = stripQuotes(rawValue);
+    }
+    index += 1;
+  }
+  if (!meta.id || !meta.label || !meta.description) return null;
+  return meta;
+}
+function parseOutcomeKind(frontmatterBlock) {
+  for (const line of frontmatterBlock.split("\n")) {
+    const match = /^kind:\s*(.*)$/.exec(line.trim());
+    if (!match) continue;
+    const value = stripQuotes(match[1]);
+    if (value === "research" || value === "proposal" || value === "artifact") return value;
+    return null;
+  }
+  return null;
+}
+function parseOutcomeMarkdown(raw) {
+  const frontmatterMatch = FRONTMATTER_RE.exec(raw);
+  if (!frontmatterMatch) return null;
+  const [, frontmatterBlock, body] = frontmatterMatch;
+  const kind = parseOutcomeKind(frontmatterBlock);
+  if (!kind) return null;
+  const fenceMatch = JSON_FENCE_RE.exec(body);
+  if (!fenceMatch) {
+    return kind === "artifact" ? { kind, prose: body.trim() } : null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fenceMatch[1]);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const prose = body.slice(fenceMatch.index + fenceMatch[0].length).trim();
+  return { kind, schema: parsed, prose };
+}
+const OUTCOME_UNSUPPORTED_KEYWORDS = [
+  "oneOf",
+  "anyOf",
+  "allOf",
+  "not",
+  "$ref",
+  "format",
+  "patternProperties",
+  "pattern",
+  "additionalItems",
+  "propertyNames",
+  "if",
+  "then",
+  "else"
+];
+const OUTCOME_SUPPORTED_TYPES = ["object", "array", "string", "number", "integer", "boolean"];
+function assertOutcomeSchemaSupported(node, where, path2 = "$") {
+  if (typeof node !== "object" || node === null || Array.isArray(node)) {
+    throw new Error(`[internal] malformed OUTCOME.md at ${where}: schema node at ${path2} must be an object`);
+  }
+  const schema = node;
+  for (const keyword of OUTCOME_UNSUPPORTED_KEYWORDS) {
+    if (keyword in schema) {
+      throw new Error(`[internal] malformed OUTCOME.md at ${where}: unsupported keyword "${keyword}" at ${path2}`);
+    }
+  }
+  if ("const" in schema) return;
+  const type = schema.type;
+  if (typeof type !== "string" || !OUTCOME_SUPPORTED_TYPES.includes(type)) {
+    throw new Error(`[internal] malformed OUTCOME.md at ${where}: missing/unsupported "type" at ${path2}`);
+  }
+  if (type === "object" && schema.properties != null) {
+    if (typeof schema.properties !== "object" || schema.properties === null || Array.isArray(schema.properties)) {
+      throw new Error(`[internal] malformed OUTCOME.md at ${where}: "properties" at ${path2} must be an object`);
+    }
+    for (const [key, child] of Object.entries(schema.properties)) {
+      assertOutcomeSchemaSupported(child, where, `${path2}.${key}`);
+    }
+  }
+  if (type === "array") {
+    if (schema.items == null) {
+      throw new Error(`[internal] malformed OUTCOME.md at ${where}: array at ${path2} requires "items"`);
+    }
+    assertOutcomeSchemaSupported(schema.items, where, `${path2}[]`);
+  }
+}
+function sanitizeAgentName(id) {
+  return id.replace(/[^a-z0-9_-]/gi, "_");
+}
+function discoverSampleInput(dir) {
+  const samplePath = path.join(dir, "SAMPLE.json");
+  if (!fs.existsSync(samplePath)) return void 0;
+  try {
+    return JSON.parse(fs.readFileSync(samplePath, "utf8"));
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`[internal] malformed SAMPLE.json at ${dir}: ${detail}`);
+  }
+}
+const FACT_SOURCES = ["input", "payload", "output"];
+const FACT_FORMATS = ["text", "number", "boolean", "percent"];
+function discoverFacts(dir) {
+  const factsPath = path.join(dir, "FACTS.json");
+  if (!fs.existsSync(factsPath)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(factsPath, "utf8"));
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`[internal] malformed FACTS.json at ${dir}: ${detail}`);
+  }
+  const entries = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.facts) ? parsed.facts : null;
+  if (!entries) {
+    throw new Error(`[internal] malformed FACTS.json at ${dir}: expected an array or { "facts": [...] }`);
+  }
+  return entries.map((entry, index) => {
+    const fact = entry;
+    if (!fact || typeof fact.label !== "string" || !fact.label.trim() || typeof fact.path !== "string" || !fact.path.trim() || !FACT_SOURCES.includes(fact.source)) {
+      throw new Error(
+        `[internal] malformed FACTS.json at ${dir}: entry ${index} needs label (string), source (${FACT_SOURCES.join("|")}), path (string)`
+      );
+    }
+    if (fact.format !== void 0 && !FACT_FORMATS.includes(fact.format)) {
+      throw new Error(
+        `[internal] malformed FACTS.json at ${dir}: entry ${index} format must be one of ${FACT_FORMATS.join("|")}`
+      );
+    }
+    return {
+      label: fact.label.trim(),
+      source: fact.source,
+      path: fact.path.trim(),
+      ...fact.format !== void 0 ? { format: fact.format } : {}
+    };
+  });
+}
+function sanitizeSkillName(id) {
+  const name = id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return name || "skill";
+}
+function parseSkillMarkdown(raw) {
+  const match = FRONTMATTER_RE.exec(raw);
+  if (!match) return null;
+  const [, frontmatterBlock, body] = match;
+  const meta = { tools: [] };
+  const lines = frontmatterBlock.split("\n");
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (!line.trim()) {
+      index += 1;
+      continue;
+    }
+    const lineMatch = /^([A-Za-z0-9_]+):\s*(.*)$/.exec(line);
+    if (!lineMatch) {
+      index += 1;
+      continue;
+    }
+    const key = lineMatch[1];
+    const rawValue = lineMatch[2].trim();
+    if (key === "tools") {
+      if (rawValue.startsWith("[")) {
+        meta.tools = parseInlineList(rawValue);
+        index += 1;
+        continue;
+      }
+      const items = [];
+      index += 1;
+      while (index < lines.length && /^\s*-\s+/.test(lines[index])) {
+        items.push(stripQuotes(lines[index].replace(/^\s*-\s+/, "")));
+        index += 1;
+      }
+      meta.tools = items.filter(Boolean);
+      continue;
+    }
+    if (key === "id" || key === "label" || key === "description") {
+      meta[key] = stripQuotes(rawValue);
+    }
+    index += 1;
+  }
+  return { meta, body: body.trim() };
+}
+function listExampleBodies(skillDir) {
+  const examplesDir = path.join(skillDir, "examples");
+  if (!fs.existsSync(examplesDir) || !fs.statSync(examplesDir).isDirectory()) return [];
+  return fs.readdirSync(examplesDir).filter((name) => name.endsWith(".md")).sort((a, b) => a.localeCompare(b)).map((name) => fs.readFileSync(path.join(examplesDir, name), "utf8").trim()).filter(Boolean);
+}
+function validateScriptSource(file, source) {
+  const definesRun = /(^|\b)(async\s+)?function\s+run\b/.test(source) || /\brun\s*=/.test(source);
+  if (!definesRun) {
+    throw new Error(
+      `[internal] malformed agent script at ${file}: must define a \`run(args)\` function`
+    );
+  }
+}
+function listScripts(scriptsDir) {
+  if (!fs.existsSync(scriptsDir) || !fs.statSync(scriptsDir).isDirectory()) return [];
+  const scripts = [];
+  for (const name of fs.readdirSync(scriptsDir).filter((entry) => entry.endsWith(".ts") || entry.endsWith(".js")).sort((a, b) => a.localeCompare(b))) {
+    const file = path.join(scriptsDir, name);
+    const source = fs.readFileSync(file, "utf8");
+    validateScriptSource(file, source);
+    scripts.push({ name: name.replace(/\.(ts|js)$/, ""), source });
+  }
+  return scripts;
+}
+const AGENT_TOOLS_SKILL_ID = "__agent_tools__";
+const TOOL_REF_RE = /^\s*\/\/\s*@ref:?\s+(\S+)/;
+function discoverToolFiles(agentDir) {
+  const toolsBase = path.join(agentDir, "tools");
+  if (!fs.existsSync(toolsBase) || !fs.statSync(toolsBase).isDirectory()) {
+    return { refs: [], scripts: [] };
+  }
+  const refs = [];
+  const scripts = [];
+  for (const name of fs.readdirSync(toolsBase).filter((entry) => entry.endsWith(".ts") || entry.endsWith(".js")).sort((a, b) => a.localeCompare(b))) {
+    const file = path.join(toolsBase, name);
+    const source = fs.readFileSync(file, "utf8");
+    const firstLine = source.split("\n", 1)[0] ?? "";
+    const refMatch = TOOL_REF_RE.exec(firstLine);
+    if (refMatch) {
+      refs.push(refMatch[1]);
+      continue;
+    }
+    validateScriptSource(file, source);
+    scripts.push({ name: name.replace(/\.(ts|js)$/, ""), source });
+  }
+  return { refs, scripts };
+}
+function discoverAgentSkills(agentDir, skillIds) {
+  if (skillIds.length === 0) return [];
+  const skillsBase = path.join(agentDir, "skills");
+  if (!fs.existsSync(skillsBase) || !fs.statSync(skillsBase).isDirectory()) return [];
+  const bySkillId = /* @__PURE__ */ new Map();
+  for (const entry of fs.readdirSync(skillsBase, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const skillDir = path.join(skillsBase, entry.name);
+    const skillPath = path.join(skillDir, "SKILL.md");
+    if (!fs.existsSync(skillPath)) continue;
+    const parsed = parseSkillMarkdown(fs.readFileSync(skillPath, "utf8"));
+    if (!parsed) {
+      throw new Error(`[internal] malformed SKILL.md at ${skillDir}: missing frontmatter block`);
+    }
+    const id = parsed.meta.id || entry.name;
+    const templatePath = path.join(skillDir, "TEMPLATE.md");
+    const template = fs.existsSync(templatePath) ? fs.readFileSync(templatePath, "utf8").trim() || void 0 : void 0;
+    bySkillId.set(id, {
+      id,
+      description: parsed.meta.description ?? "",
+      instructions: parsed.body,
+      template,
+      examples: listExampleBodies(skillDir),
+      tools: parsed.meta.tools,
+      scripts: listScripts(path.join(skillDir, "scripts")),
+      openCodeSkillName: sanitizeSkillName(id)
+    });
+  }
+  const resolved = [];
+  for (const skillId of skillIds) {
+    const skill = bySkillId.get(skillId);
+    if (skill) resolved.push(skill);
+  }
+  return resolved;
+}
+function discoverSubAgents(agentDir) {
+  const base = path.join(agentDir, "sub-agents");
+  if (!fs.existsSync(base) || !fs.statSync(base).isDirectory()) return [];
+  const subAgents = [];
+  for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name === "__tests__") continue;
+    const dir = path.join(base, entry.name);
+    const agentMdPath = path.join(dir, "AGENT.md");
+    const outcomePath = path.join(dir, "OUTCOME.md");
+    if (!fs.existsSync(agentMdPath) || !fs.existsSync(outcomePath)) {
+      throw new Error(
+        `[internal] malformed sub-agent at ${dir}: both AGENT.md and OUTCOME.md are required`
+      );
+    }
+    const agent = parseAgentMarkdown(fs.readFileSync(agentMdPath, "utf8"));
+    if (!agent) {
+      throw new Error(`[internal] malformed AGENT.md at ${dir}: missing id/label/description`);
+    }
+    const outcome = parseOutcomeMarkdown(fs.readFileSync(outcomePath, "utf8"));
+    if (!outcome) {
+      throw new Error(`[internal] malformed OUTCOME.md at ${dir}: missing kind or JSON-Schema block`);
+    }
+    if (outcome.schema) assertOutcomeSchemaSupported(outcome.schema, dir);
+    if (outcome.kind !== "research") {
+      throw new Error(
+        `[internal] sub-agent at ${dir} must be research (kind: research); only the primary proposes`
+      );
+    }
+    if (agent.subAgents.length > 0) {
+      throw new Error(
+        `[internal] sub-agent at ${dir} may not declare subAgents (depth cap = 1); sub-agents may not delegate further`
+      );
+    }
+    const skillsContent = discoverAgentSkills(dir, agent.skills);
+    const skillTools = skillsContent.flatMap((skill) => skill.tools);
+    const toolFiles = discoverToolFiles(dir);
+    const effectiveSkillsContent = toolFiles.scripts.length > 0 ? [
+      ...skillsContent,
+      {
+        id: AGENT_TOOLS_SKILL_ID,
+        description: "",
+        instructions: "",
+        examples: [],
+        tools: [],
+        scripts: toolFiles.scripts,
+        openCodeSkillName: sanitizeSkillName(AGENT_TOOLS_SKILL_ID)
+      }
+    ] : skillsContent;
+    const effectiveTools = Array.from(
+      /* @__PURE__ */ new Set([...agent.tools, ...skillTools, ...toolFiles.refs])
+    );
+    subAgents.push({
+      moduleId: "",
+      dir,
+      id: agent.id,
+      label: agent.label,
+      description: agent.description,
+      instructions: agent.instructions,
+      resultKind: outcome.kind,
+      outcomeSchema: outcome.schema,
+      outcomeProse: outcome.prose,
+      tools: effectiveTools,
+      skills: agent.skills,
+      subAgents: [],
+      openCodeAgentName: sanitizeAgentName(agent.id),
+      skillsContent: effectiveSkillsContent,
+      subAgentsContent: [],
+      mode: "subagent",
+      maxSteps: agent.maxSteps,
+      provider: agent.provider,
+      model: agent.model,
+      sampleInput: discoverSampleInput(dir),
+      facts: discoverFacts(dir),
+      tokenUsage: discoverAgentTokenUsage(dir),
+      sourceFiles: collectAgentFiles(dir)
+    });
+  }
+  return subAgents;
+}
+const TOKEN_TOOL_EXTENSIONS = [".ts", ".js"];
+function toPosixRelativePath(relativePath) {
+  return relativePath.split(path.sep).join("/");
+}
+function tokenCountFile(agentDir, relativePath) {
+  const absolute = path.join(agentDir, relativePath);
+  if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) return null;
+  return { path: toPosixRelativePath(relativePath), tokens: countTokens(fs.readFileSync(absolute, "utf8")) };
+}
+function tokenListFiles(dir, extensions) {
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return [];
+  return fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => !extensions || extensions.includes(path.extname(name))).sort((a, b) => a.localeCompare(b));
+}
+function tokenListDirs(dir) {
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return [];
+  return fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "__tests__").map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+}
+function tokenComputeSkills(agentDir) {
+  return tokenListDirs(path.join(agentDir, "skills")).map((skillId) => {
+    const skillRel = path.join("skills", skillId);
+    const files = [];
+    for (const name of ["SKILL.md", "TEMPLATE.md"]) {
+      const file = tokenCountFile(agentDir, path.join(skillRel, name));
+      if (file) files.push(file);
+    }
+    for (const subdir of ["examples", "scripts"]) {
+      for (const name of tokenListFiles(path.join(agentDir, skillRel, subdir))) {
+        const file = tokenCountFile(agentDir, path.join(skillRel, subdir, name));
+        if (file) files.push(file);
+      }
+    }
+    return { id: skillId, tokens: files.reduce((sum, f) => sum + f.tokens, 0), files };
+  });
+}
+function tokenComputeTools(agentDir) {
+  return tokenListFiles(path.join(agentDir, "tools"), TOKEN_TOOL_EXTENSIONS).map((name) => {
+    const rel = path.join("tools", name);
+    return {
+      name: name.replace(/\.[^.]+$/, ""),
+      path: toPosixRelativePath(rel),
+      tokens: countTokens(fs.readFileSync(path.join(agentDir, rel), "utf8"))
+    };
+  });
+}
+function discoverAgentTokenUsage(agentDir, depth = 0) {
+  const agent = tokenCountFile(agentDir, "AGENT.md")?.tokens ?? 0;
+  const outcome = tokenCountFile(agentDir, "OUTCOME.md")?.tokens ?? 0;
+  const skills = tokenComputeSkills(agentDir);
+  const tools = tokenComputeTools(agentDir);
+  const subAgents = [];
+  if (depth === 0) {
+    for (const subId of tokenListDirs(path.join(agentDir, "sub-agents"))) {
+      const nested = discoverAgentTokenUsage(path.join(agentDir, "sub-agents", subId), depth + 1);
+      subAgents.push({ id: subId, tokens: nested.total });
+    }
+  }
+  const self = agent + outcome + skills.reduce((sum, s) => sum + s.tokens, 0) + tools.reduce((sum, t) => sum + t.tokens, 0);
+  const total = self + subAgents.reduce((sum, s) => sum + s.tokens, 0);
+  return { total, self, agent, outcome, skills, tools, subAgents };
+}
+const AGENT_AUX_FILES = ["SAMPLE.json", "FACTS.json"];
+function collectAgentFiles(agentDir, prefix = "", depth = 0) {
+  const files = [];
+  const add = (relativePath, inContext) => {
+    const absolute = path.join(agentDir, relativePath);
+    if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) return;
+    const content = fs.readFileSync(absolute, "utf8");
+    files.push({ path: toPosixRelativePath(path.join(prefix, relativePath)), content, tokens: countTokens(content), inContext });
+  };
+  add("AGENT.md", true);
+  add("OUTCOME.md", true);
+  for (const name of AGENT_AUX_FILES) add(name, false);
+  for (const skillId of tokenListDirs(path.join(agentDir, "skills"))) {
+    const skillRel = path.join("skills", skillId);
+    for (const name of ["SKILL.md", "TEMPLATE.md"]) add(path.join(skillRel, name), true);
+    for (const subdir of ["examples", "scripts"]) {
+      for (const name of tokenListFiles(path.join(agentDir, skillRel, subdir))) {
+        add(path.join(skillRel, subdir, name), true);
+      }
+    }
+  }
+  for (const name of tokenListFiles(path.join(agentDir, "tools"), TOKEN_TOOL_EXTENSIONS)) {
+    add(path.join("tools", name), true);
+  }
+  if (depth === 0) {
+    for (const subId of tokenListDirs(path.join(agentDir, "sub-agents"))) {
+      files.push(
+        ...collectAgentFiles(
+          path.join(agentDir, "sub-agents", subId),
+          path.join(prefix, "sub-agents", subId),
+          depth + 1
+        )
+      );
+    }
+  }
+  return files;
+}
+function renderOpenCodeSkillFile(skill) {
+  const frontmatter = [
+    "---",
+    `name: ${skill.openCodeSkillName}`,
+    `description: ${JSON.stringify(skill.description)}`,
+    "---"
+  ];
+  return `${frontmatter.join("\n")}
+${skill.instructions.trim()}
+`;
+}
+function findRepoRoot(start) {
+  let current = path.resolve(start);
+  for (let depth = 0; depth < 40; depth += 1) {
+    if (fs.existsSync(path.join(current, "docker", "opencode")) && fs.existsSync(path.join(current, "packages"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function listAgentDirs(agentsBase) {
+  if (!fs.existsSync(agentsBase)) return [];
+  return fs.readdirSync(agentsBase, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "__tests__").map((entry) => path.join(agentsBase, entry.name));
+}
+function renderToolPermissionLine(toolName) {
+  return `  ${JSON.stringify(toolName)}: true`;
+}
+const ORCHESTRATOR_MODULE_ID = "agent_orchestrator";
+const OPENCODE_MCP_SERVER_KEY = "open-mercato";
+const CORE_FILE_AGENT_TOOL_IDS = [
+  "agent_orchestrator.submit_outcome",
+  "agent_orchestrator.load_skill",
+  "agent_orchestrator.run_skill_script"
+];
+const DELEGATE_AGENT_TOOL_ID = "agent_orchestrator.delegate_agent";
+function toOpenCodeMcpToolId(omToolId) {
+  return `${OPENCODE_MCP_SERVER_KEY}_${omToolId.replace(/\./g, "_")}`;
+}
+function renderOpenCodeAgentFile(agent) {
+  const subAgentIds = agent.mode === "primary" ? agent.subAgentsContent.map((sub) => sub.id) : [];
+  const hasSubAgents = subAgentIds.length > 0;
+  const omMcpToolIds = Array.from(
+    /* @__PURE__ */ new Set([
+      ...agent.tools,
+      ...CORE_FILE_AGENT_TOOL_IDS,
+      ...hasSubAgents ? [DELEGATE_AGENT_TOOL_ID] : []
+    ])
+  );
+  const allowedTools = omMcpToolIds.map(toOpenCodeMcpToolId);
+  const modelLine = agent.provider && agent.model ? `model: ${agent.provider}/${agent.model}` : agent.model ? `model: ${agent.model}` : null;
+  const frontmatterLines = [
+    "---",
+    `description: ${JSON.stringify(agent.description)}`,
+    ...modelLine ? [modelLine] : [],
+    `mode: ${agent.mode}`,
+    "tools:",
+    '  "*": false',
+    ...allowedTools.map(renderToolPermissionLine),
+    "permission:",
+    "  write: deny",
+    "  edit: deny",
+    "  bash: deny",
+    "  task: deny",
+    "---"
+  ];
+  const terminalInstruction = `Finish by calling the \`${toOpenCodeMcpToolId("agent_orchestrator.submit_outcome")}\` tool with a value matching the outcome contract (pass it as the \`outcome\` argument). You MUST call the tool \u2014 do not answer in prose or emit the result as a code block.`;
+  const delegateToolName = toOpenCodeMcpToolId(DELEGATE_AGENT_TOOL_ID);
+  const subAgentSection = hasSubAgents ? `## Sub-agents
+Delegate a sub-task by calling the \`${delegateToolName}\` tool with \`{ agentId: "<sub-agent id>", input: <sub-task input object> }\`. Issue multiple \`${delegateToolName}\` calls in the SAME step to fan out in parallel, then combine their results before submitting your outcome. Available sub-agents: ${subAgentIds.join(", ")}.` : null;
+  const outcomeTarget = agent.resultKind === "proposal" ? "the `proposal` object" : "the `data` object";
+  const outcomeSection = agent.resultKind === "artifact" ? [
+    "## Outcome contract",
+    "Write the files you produce into the run's `out/` directory, then pass this shape as the `outcome` argument of the submit_outcome tool:",
+    "",
+    "```json",
+    JSON.stringify(
+      {
+        artifacts: [
+          { fileName: "report.pdf", mimeType: "application/pdf", caption: "What this file is" }
+        ],
+        summary: "One sentence about what you produced."
+      },
+      null,
+      2
+    ),
+    "```",
+    ...agent.outcomeProse ? ["", agent.outcomeProse] : []
+  ].join("\n") : [
+    "## Outcome contract",
+    `Your result MUST match this JSON Schema (${outcomeTarget}). Pass it as the \`outcome\` argument of the submit_outcome tool, as a JSON object (not a string):`,
+    "",
+    "```json",
+    JSON.stringify(agent.outcomeSchema, null, 2),
+    "```",
+    ...agent.outcomeProse ? ["", agent.outcomeProse] : []
+  ].join("\n");
+  const body = [
+    agent.instructions.trim(),
+    ...subAgentSection ? [subAgentSection] : [],
+    outcomeSection,
+    terminalInstruction
+  ].filter(Boolean).join("\n\n");
+  return `${frontmatterLines.join("\n")}
+${body}
+`;
+}
+function renderDescriptor(agent, indent) {
+  const optional = [];
+  if (agent.subAgentsContent.length > 0) {
+    const nested = agent.subAgentsContent.map((sub) => renderDescriptor(sub, `${indent}  `)).join("\n");
+    optional.push(`${indent}  subAgentDescriptors: [
+${nested}
+${indent}  ],`);
+  }
+  if (agent.maxSteps != null) optional.push(`${indent}  maxSteps: ${agent.maxSteps},`);
+  if (agent.provider != null) optional.push(`${indent}  provider: ${JSON.stringify(agent.provider)},`);
+  if (agent.model != null) optional.push(`${indent}  model: ${JSON.stringify(agent.model)},`);
+  if (agent.sampleInput !== void 0) {
+    optional.push(`${indent}  sampleInput: ${JSON.stringify(agent.sampleInput)},`);
+  }
+  if (agent.facts !== void 0) {
+    optional.push(`${indent}  facts: ${JSON.stringify(agent.facts)},`);
+  }
+  const skillsContent = agent.skillsContent.map((skill) => ({
+    id: skill.id,
+    instructions: skill.instructions,
+    ...skill.template != null ? { template: skill.template } : {},
+    examples: skill.examples,
+    tools: skill.tools,
+    ...skill.scripts.length > 0 ? { scripts: skill.scripts } : {}
+  }));
+  return [
+    `${indent}{`,
+    `${indent}  id: ${JSON.stringify(agent.id)},`,
+    `${indent}  moduleId: ${JSON.stringify(agent.moduleId)},`,
+    `${indent}  label: ${JSON.stringify(agent.label)},`,
+    `${indent}  description: ${JSON.stringify(agent.description)},`,
+    `${indent}  instructions: ${JSON.stringify(agent.instructions)},`,
+    `${indent}  resultKind: ${JSON.stringify(agent.resultKind)},`,
+    ...agent.outcomeSchema ? [`${indent}  outcomeSchema: ${JSON.stringify(agent.outcomeSchema)},`] : [],
+    `${indent}  tools: ${JSON.stringify(agent.tools)},`,
+    `${indent}  skills: ${JSON.stringify(agent.skills)},`,
+    `${indent}  subAgents: ${JSON.stringify(agent.subAgents)},`,
+    `${indent}  openCodeAgentName: ${JSON.stringify(agent.openCodeAgentName)},`,
+    `${indent}  skillsContent: ${JSON.stringify(skillsContent)},`,
+    `${indent}  tokenUsage: ${JSON.stringify(agent.tokenUsage)},`,
+    `${indent}  sourceFiles: ${JSON.stringify(agent.sourceFiles)},`,
+    ...optional,
+    `${indent}},`
+  ].join("\n");
+}
+function renderManifest(agents) {
+  const descriptors = agents.map((agent) => renderDescriptor(agent, "  ")).join("\n");
+  return `// AUTO-GENERATED by mercato generate registry \u2014 DO NOT EDIT BY HAND.
+//
+// Committed, generator-owned manifest of file-defined (OpenCode) agents,
+// discovered from \`agents/<id>/\` directories across every enabled module. It
+// stores PLAIN data (raw JSON-Schema, not a Zod instance) so this file is pure
+// data and travels with the repo (survives \`yarn clean-generated\`).
+// \`ensureAgentsLoaded()\` recompiles each \`outcomeSchema\` to Zod via
+// \`compileOutcome\` at load time and registers it with \`runtime:'opencode'\`.
+//
+// Regenerate with \`yarn generate\`.
+import type { JsonSchemaNode, OutcomeKind } from "../lib/sdk/outcomeSchema.js"
+import type { AgentTokenUsage, FileAgentFile } from "../lib/tokens/types.js"
+
+export type FileAgentScript = {
+  name: string
+  source: string
+}
+
+export type FileAgentSkillContent = {
+  id: string
+  instructions: string
+  template?: string
+  examples: string[]
+  tools: string[]
+  /**
+   * Sandboxed helper scripts (Phase 5). Carried as plain source; run server-side
+   * in the Code Mode \`isolated-vm\` sandbox via the \`run_skill_script\` MCP tool.
+   * Never copied to the OpenCode container. The synthetic skill id
+   * \`__agent_tools__\` carries an agent's LOCAL \`tools/*.ts\` sources.
+   */
+  scripts?: FileAgentScript[]
+}
+
+export type FileAgentFact = {
+  /** Human label shown in the Caseload facts grid. */
+  label: string
+  /** Where to resolve the value: run input, proposal payload, or run output. */
+  source: 'input' | 'payload' | 'output'
+  /** Dot-path into the source (array indexes allowed), e.g. "actions.0.payload.amount". */
+  path: string
+  format?: 'text' | 'number' | 'boolean' | 'percent'
+}
+
+export type FileAgentDescriptor = {
+  id: string
+  moduleId: string
+  label: string
+  description: string
+  instructions: string
+  resultKind: OutcomeKind
+  outcomeSchema?: JsonSchemaNode
+  tools: string[]
+  skills: string[]
+  subAgents: string[]
+  openCodeAgentName: string
+  skillsContent?: FileAgentSkillContent[]
+  /**
+   * Baked token-usage estimate of the agent's construction files (AGENT.md,
+   * OUTCOME.md, skills, tools, sub-agents), counted with the shared
+   * \`o200k_base\` tokenizer. Surfaced on the Agent detail page and the
+   * \`agent_orchestrator token-usage\` CLI. An estimate, not an exact count.
+   */
+  tokenUsage?: AgentTokenUsage
+  /**
+   * Baked raw content of every construction file (AGENT.md, OUTCOME.md, skills,
+   * tools, sub-agents, and auxiliary SAMPLE.json/FACTS.json), for the read-only
+   * Files tab. Each carries its \`o200k_base\` token count; paths are relative to
+   * the agent root (sub-agent files prefixed \`sub-agents/<id>/\`). Baked so the
+   * runtime never reads agent dirs from disk.
+   */
+  sourceFiles?: FileAgentFile[]
+  /**
+   * Nested descriptors for this agent's sub-agents (Phase 4). Each is an
+   * research-kind, non-delegating file agent registered individually (depth cap =
+   * 1). Absent for agents without sub-agents and for sub-agents themselves.
+   */
+  subAgentDescriptors?: FileAgentDescriptor[]
+  maxSteps?: number
+  provider?: string
+  model?: string
+  /**
+   * Optional example \`input\` for the Playground "Insert sample" button, read
+   * from \`agents/<id>/SAMPLE.json\`. Any JSON value the agent accepts as input.
+   */
+  sampleInput?: unknown
+  /**
+   * Optional fact declarations for the Caseload decision panel, read from
+   * \`agents/<id>/FACTS.json\`. Each maps a labelled dot-path into the run
+   * input / proposal payload / run output.
+   */
+  facts?: FileAgentFact[]
+}
+
+export const fileAgentDescriptors: FileAgentDescriptor[] = [${descriptors ? `
+${descriptors}
+` : ""}]
+`;
+}
+function createAgentFilesExtension() {
+  const discovered = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  let repoRoot = null;
+  let sawOrchestratorModule = false;
+  function scanAgentsTree(moduleId, baseDir) {
+    for (const dir of listAgentDirs(baseDir)) {
+      const agentMdPath = path.join(dir, "AGENT.md");
+      const outcomePath = path.join(dir, "OUTCOME.md");
+      const hasAgentMd = fs.existsSync(agentMdPath);
+      const hasOutcome = fs.existsSync(outcomePath);
+      if (!hasAgentMd && !hasOutcome) continue;
+      if (!hasAgentMd || !hasOutcome) {
+        throw new Error(
+          `[internal] malformed file agent at ${dir}: both AGENT.md and OUTCOME.md are required`
+        );
+      }
+      const agent = parseAgentMarkdown(fs.readFileSync(agentMdPath, "utf8"));
+      if (!agent) {
+        throw new Error(`[internal] malformed AGENT.md at ${dir}: missing id/label/description`);
+      }
+      const outcome = parseOutcomeMarkdown(fs.readFileSync(outcomePath, "utf8"));
+      if (!outcome) {
+        throw new Error(`[internal] malformed OUTCOME.md at ${dir}: missing kind or JSON-Schema block`);
+      }
+      if (outcome.schema) assertOutcomeSchemaSupported(outcome.schema, dir);
+      if (!/^[a-z0-9][a-z0-9._-]*$/.test(agent.id)) {
+        throw new Error(
+          `[internal] invalid agent id "${agent.id}" at ${dir}: use lowercase [a-z0-9._-] (e.g. "module.agent")`
+        );
+      }
+      if (seenIds.has(agent.id)) {
+        console.warn(`[internal] duplicate file-agent id "${agent.id}" at ${dir}; keeping the first, skipping this one.`);
+        continue;
+      }
+      seenIds.add(agent.id);
+      const skillsContent = discoverAgentSkills(dir, agent.skills);
+      const skillTools = skillsContent.flatMap((skill) => skill.tools);
+      const toolFiles = discoverToolFiles(dir);
+      const effectiveSkillsContent = toolFiles.scripts.length > 0 ? [
+        ...skillsContent,
+        {
+          id: AGENT_TOOLS_SKILL_ID,
+          description: "",
+          instructions: "",
+          examples: [],
+          tools: [],
+          scripts: toolFiles.scripts,
+          openCodeSkillName: sanitizeSkillName(AGENT_TOOLS_SKILL_ID)
+        }
+      ] : skillsContent;
+      const effectiveTools = Array.from(
+        /* @__PURE__ */ new Set([...agent.tools, ...skillTools, ...toolFiles.refs])
+      );
+      const subAgentsContent = discoverSubAgents(dir);
+      discovered.push({
+        moduleId,
+        dir,
+        id: agent.id,
+        label: agent.label,
+        description: agent.description,
+        instructions: agent.instructions,
+        resultKind: outcome.kind,
+        outcomeSchema: outcome.schema,
+        outcomeProse: outcome.prose,
+        tools: effectiveTools,
+        skills: agent.skills,
+        subAgents: agent.subAgents,
+        openCodeAgentName: sanitizeAgentName(agent.id),
+        skillsContent: effectiveSkillsContent,
+        subAgentsContent,
+        mode: "primary",
+        maxSteps: agent.maxSteps,
+        provider: agent.provider,
+        model: agent.model,
+        sampleInput: discoverSampleInput(dir),
+        facts: discoverFacts(dir),
+        tokenUsage: discoverAgentTokenUsage(dir),
+        sourceFiles: collectAgentFiles(dir)
+      });
+    }
+  }
+  return {
+    id: "registry.agent-files",
+    outputFiles: [],
+    scanModule(ctx) {
+      if (ctx.moduleId === ORCHESTRATOR_MODULE_ID) sawOrchestratorModule = true;
+      if (!repoRoot) {
+        repoRoot = findRepoRoot(ctx.roots.pkgBase) ?? findRepoRoot(ctx.roots.appBase);
+      }
+      const pkgScanBase = resolveStandaloneSourceMirrorBase(ctx.roots.pkgBase) ?? ctx.roots.pkgBase;
+      scanAgentsTree(ctx.moduleId, path.join(pkgScanBase, "agents"));
+      scanAgentsTree(ctx.moduleId, path.join(ctx.roots.appBase, "agents"));
+    },
+    generateOutput() {
+      const sorted = [...discovered].sort((a, b) => a.id.localeCompare(b.id));
+      if (!repoRoot) {
+        return /* @__PURE__ */ new Map();
+      }
+      if (!sawOrchestratorModule && sorted.length === 0) {
+        return /* @__PURE__ */ new Map();
+      }
+      const manifestPath = path.join(
+        repoRoot,
+        "packages",
+        "enterprise",
+        "src",
+        "modules",
+        "agent_orchestrator",
+        "generated",
+        "file-agents.generated.ts"
+      );
+      fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+      fs.writeFileSync(manifestPath, renderManifest(sorted), "utf8");
+      const dockerAgentsDir = path.join(repoRoot, "docker", "opencode", "agents");
+      fs.mkdirSync(dockerAgentsDir, { recursive: true });
+      const desiredFiles = /* @__PURE__ */ new Map();
+      for (const agent of sorted) {
+        desiredFiles.set(`${agent.openCodeAgentName}.md`, renderOpenCodeAgentFile(agent));
+        for (const sub of agent.subAgentsContent) {
+          desiredFiles.set(`${sub.openCodeAgentName}.md`, renderOpenCodeAgentFile(sub));
+        }
+      }
+      for (const existing of fs.existsSync(dockerAgentsDir) ? fs.readdirSync(dockerAgentsDir) : []) {
+        if (existing.endsWith(".md") && !desiredFiles.has(existing)) {
+          fs.rmSync(path.join(dockerAgentsDir, existing));
+        }
+      }
+      for (const [fileName, content] of desiredFiles) {
+        fs.writeFileSync(path.join(dockerAgentsDir, fileName), content, "utf8");
+      }
+      const allAgents = sorted.flatMap((agent) => [agent, ...agent.subAgentsContent]);
+      const dockerSkillsDir = path.join(repoRoot, "docker", "opencode", "skills");
+      const isNativeSkill = (skill) => skill.id !== AGENT_TOOLS_SKILL_ID;
+      const desiredSkillNames = /* @__PURE__ */ new Set();
+      for (const agent of allAgents) {
+        for (const skill of agent.skillsContent) {
+          if (isNativeSkill(skill)) desiredSkillNames.add(skill.openCodeSkillName);
+        }
+      }
+      if (desiredSkillNames.size > 0) fs.mkdirSync(dockerSkillsDir, { recursive: true });
+      if (fs.existsSync(dockerSkillsDir)) {
+        for (const existing of fs.readdirSync(dockerSkillsDir, { withFileTypes: true })) {
+          if (existing.isDirectory() && !desiredSkillNames.has(existing.name)) {
+            fs.rmSync(path.join(dockerSkillsDir, existing.name), { recursive: true, force: true });
+          }
+        }
+      }
+      const renderedSkillNames = /* @__PURE__ */ new Set();
+      for (const agent of allAgents) {
+        for (const skill of agent.skillsContent) {
+          if (!isNativeSkill(skill)) continue;
+          if (renderedSkillNames.has(skill.openCodeSkillName)) continue;
+          renderedSkillNames.add(skill.openCodeSkillName);
+          const skillDir = path.join(dockerSkillsDir, skill.openCodeSkillName);
+          fs.mkdirSync(skillDir, { recursive: true });
+          fs.writeFileSync(path.join(skillDir, "SKILL.md"), renderOpenCodeSkillFile(skill), "utf8");
+        }
+      }
+      return /* @__PURE__ */ new Map();
+    }
+  };
+}
+export {
+  createAgentFilesExtension
+};
+//# sourceMappingURL=agent-files.js.map