opencode-swarm 7.82.2 → 7.84.0

package/dist/cli/index-wg3r6acj.js

@@ -0,0 +1,2042 @@
+// @bun
+import {
+  exports_external
+} from "./index-293f68mj.js";
+
+// src/config/agent-names.ts
+var QA_AGENTS = ["reviewer", "critic", "critic_oversight"];
+var PIPELINE_AGENTS = ["explorer", "coder", "test_engineer"];
+var ORCHESTRATOR_NAME = "architect";
+var ALL_SUBAGENT_NAMES = [
+  "sme",
+  "researcher",
+  "docs",
+  "docs_design",
+  "designer",
+  "critic_sounding_board",
+  "critic_drift_verifier",
+  "critic_hallucination_verifier",
+  "critic_architecture_supervisor",
+  "curator_init",
+  "curator_phase",
+  "curator_postmortem",
+  "council_generalist",
+  "council_skeptic",
+  "council_domain_expert",
+  "skill_improver",
+  "spec_writer",
+  ...QA_AGENTS,
+  ...PIPELINE_AGENTS
+];
+var ALL_AGENT_NAMES = [
+  ORCHESTRATOR_NAME,
+  ...ALL_SUBAGENT_NAMES
+];
+
+// src/tools/tool-metadata.ts
+var TOOL_METADATA = {
+  diff: {
+    description: "structured git diff with contract change detection",
+    agents: [
+      "architect",
+      "reviewer",
+      "critic_oversight",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  diff_summary: {
+    description: "filter classified AST changes by category, risk level, or file for reviewer drill-down",
+    agents: ["architect", "reviewer", "critic_oversight"]
+  },
+  syntax_check: {
+    description: "check syntax of source files using tree-sitter parsers across multiple languages, returning per-file errors",
+    agents: ["architect", "coder", "test_engineer"]
+  },
+  placeholder_scan: {
+    description: "todo and FIXME comment detection",
+    agents: ["architect", "reviewer"]
+  },
+  imports: {
+    description: "find all consumers that import from a given file \u2014 use before refactoring shared modules to avoid breaking unseen dependents",
+    agents: [
+      "architect",
+      "sme",
+      "researcher",
+      "docs",
+      "docs_design",
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "reviewer",
+      "critic",
+      "critic_oversight",
+      "explorer",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  lint: {
+    description: "run project linter in check or fix mode; supports biome, eslint, ruff, clippy, and more, returns structured results",
+    agents: ["architect", "reviewer", "coder"]
+  },
+  secretscan: {
+    description: "scan for secrets (API keys, tokens, passwords) via regex and entropy; returns redacted previews, excludes common dirs",
+    agents: ["architect", "reviewer", "critic_oversight"]
+  },
+  sast_scan: {
+    description: "static analysis security scan",
+    agents: ["architect", "reviewer", "critic_oversight"]
+  },
+  build_check: {
+    description: "discover and run build, typecheck, and test commands for various project ecosystems in the working directory",
+    agents: ["architect", "coder", "test_engineer"]
+  },
+  pre_check_batch: {
+    description: "parallel verification: lint:check + secretscan + sast_scan + quality_budget",
+    agents: ["architect", "reviewer"]
+  },
+  quality_budget: {
+    description: "code quality budget check",
+    agents: ["architect"]
+  },
+  symbols: {
+    description: "extract exported symbols (functions, classes, interfaces, types) from source files; supports TypeScript, JavaScript, and Python",
+    agents: [
+      "architect",
+      "sme",
+      "researcher",
+      "docs",
+      "docs_design",
+      "designer",
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "spec_writer",
+      "reviewer",
+      "critic",
+      "critic_oversight",
+      "explorer",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  complexity_hotspots: {
+    description: "git churn \xD7 complexity risk map",
+    agents: [
+      "architect",
+      "sme",
+      "researcher",
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "reviewer",
+      "critic",
+      "critic_oversight",
+      "explorer",
+      "test_engineer"
+    ]
+  },
+  schema_drift: {
+    description: "OpenAPI spec vs route drift",
+    agents: ["architect", "sme", "researcher", "docs", "explorer"]
+  },
+  todo_extract: {
+    description: "structured TODO/FIXME extraction",
+    agents: ["architect", "researcher", "docs", "explorer"]
+  },
+  evidence_check: {
+    description: "verify task evidence completeness",
+    agents: ["architect", "critic_oversight"]
+  },
+  check_gate_status: {
+    description: "check the gate status of a specific task",
+    agents: ["architect", "critic_oversight"]
+  },
+  completion_verify: {
+    description: "verify completed tasks have required evidence",
+    agents: ["architect", "critic_oversight"]
+  },
+  submit_council_verdicts: {
+    description: "submit pre-collected council member verdicts for synthesis (architect MUST dispatch critic/reviewer/sme/test_engineer/explorer as Agent tasks first; this tool synthesizes only, it does not contact members)",
+    agents: []
+  },
+  submit_phase_council_verdicts: {
+    description: "submit pre-collected phase-level council member verdicts for holistic phase synthesis (architect MUST dispatch all 5 council members with phase-scoped context first; this tool synthesizes only, it does not contact members)",
+    agents: []
+  },
+  declare_council_criteria: {
+    description: "pre-declare acceptance criteria for a task before the coder starts work; criteria are read back during council evaluation",
+    agents: []
+  },
+  sbom_generate: {
+    description: "SBOM generation for dependency inventory",
+    agents: ["architect"]
+  },
+  checkpoint: {
+    description: "create named git checkpoints for save, restore, and delete \u2014 use before risky operations to enable rollback",
+    agents: ["architect"]
+  },
+  pkg_audit: {
+    description: "dependency vulnerability scan \u2014 npm/pip/cargo",
+    agents: [
+      "architect",
+      "critic_hallucination_verifier",
+      "reviewer",
+      "critic_oversight",
+      "test_engineer"
+    ]
+  },
+  test_runner: {
+    description: "auto-detect and run tests",
+    agents: ["architect", "reviewer", "test_engineer"]
+  },
+  test_impact: {
+    description: "identify test files impacted by changed source files via import analysis",
+    agents: ["architect", "reviewer", "critic_oversight", "test_engineer"]
+  },
+  mutation_test: {
+    description: "executes pre-generated mutation patches against tests, evaluates kill rate against quality gate thresholds",
+    agents: ["architect", "test_engineer"]
+  },
+  generate_mutants: {
+    description: "generate LLM-based mutation testing patches for source files; returns MutationPatch[] for direct consumption by the mutation_test tool",
+    agents: ["architect"]
+  },
+  detect_domains: {
+    description: "detect which SME domains are relevant for a given text",
+    agents: [
+      "architect",
+      "sme",
+      "docs",
+      "docs_design",
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "critic",
+      "critic_oversight",
+      "explorer"
+    ]
+  },
+  git_blame: {
+    description: "per-line git blame metadata: sha, author, date, summary for each line in a file",
+    agents: ["reviewer", "explorer", "architect"]
+  },
+  gitingest: {
+    description: "fetch a GitHub repository full content via gitingest.com",
+    agents: ["architect", "docs", "explorer"]
+  },
+  retrieve_summary: {
+    description: "retrieve the full content of a stored tool output summary",
+    agents: [
+      "architect",
+      "sme",
+      "docs",
+      "docs_design",
+      "designer",
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "critic_architecture_supervisor",
+      "spec_writer",
+      "reviewer",
+      "critic",
+      "critic_oversight",
+      "explorer",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  extract_code_blocks: {
+    description: "extract code blocks from text content and save them to files",
+    agents: [
+      "architect",
+      "sme",
+      "docs",
+      "docs_design",
+      "designer",
+      "spec_writer",
+      "reviewer",
+      "explorer",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  phase_complete: {
+    description: "mark a phase as complete and track dispatched agents",
+    agents: ["architect"]
+  },
+  save_plan: {
+    description: "save a structured implementation plan",
+    agents: ["architect"]
+  },
+  update_task_status: {
+    description: "mark tasks complete, track phase progress",
+    agents: ["architect"]
+  },
+  lint_spec: {
+    description: "validate .swarm/spec.md format and required fields",
+    agents: ["architect", "spec_writer"]
+  },
+  write_retro: {
+    description: "document phase retrospectives via phase_complete workflow, capture lessons learned",
+    agents: ["architect"]
+  },
+  write_drift_evidence: {
+    description: "write drift verification evidence for a completed phase",
+    agents: ["architect"]
+  },
+  write_hallucination_evidence: {
+    description: "write hallucination verification evidence for a completed phase",
+    agents: ["architect"]
+  },
+  write_mutation_evidence: {
+    description: "write mutation gate evidence for a completed phase; normalizes PASS/WARN/FAIL/SKIP verdicts and writes .swarm/evidence/{phase}/mutation-gate.json",
+    agents: ["architect"]
+  },
+  declare_scope: {
+    description: "declare file scope for next coder delegation",
+    agents: ["architect"]
+  },
+  knowledge_query: {
+    description: "query swarm or hive knowledge with optional filters",
+    agents: ["architect", "skill_improver", "spec_writer"]
+  },
+  doc_scan: {
+    description: "scan project documentation files and build an index manifest",
+    agents: [
+      "architect",
+      "docs_design",
+      "skill_improver",
+      "spec_writer",
+      "explorer"
+    ]
+  },
+  doc_extract: {
+    description: "extract actionable constraints from project documentation",
+    agents: ["architect", "docs_design", "skill_improver", "spec_writer"]
+  },
+  curator_analyze: {
+    description: "run curator phase analysis and optionally apply knowledge recommendations",
+    agents: ["architect"]
+  },
+  knowledge_add: {
+    description: "store a new lesson in the knowledge base",
+    agents: ["architect", "coder"]
+  },
+  knowledge_recall: {
+    description: "search the knowledge base for relevant past decisions",
+    agents: [
+      "architect",
+      "sme",
+      "docs",
+      "docs_design",
+      "designer",
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "critic_architecture_supervisor",
+      "curator_init",
+      "curator_phase",
+      "skill_improver",
+      "spec_writer",
+      "reviewer",
+      "critic",
+      "critic_oversight",
+      "explorer",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  knowledge_remove: {
+    description: "delete an outdated swarm knowledge entry by ID (swarm tier only)",
+    agents: ["architect"]
+  },
+  co_change_analyzer: {
+    description: "detect hidden couplings by analyzing git history",
+    agents: ["architect"]
+  },
+  search: {
+    description: "Workspace-scoped ripgrep-style text search with structured JSON output. Supports literal and regex modes, glob filtering, and result limits. NOTE: This is text search, not structural AST search \u2014 use symbols and imports tools for structural queries.",
+    agents: [
+      "architect",
+      "sme",
+      "docs",
+      "docs_design",
+      "designer",
+      "critic_hallucination_verifier",
+      "skill_improver",
+      "spec_writer",
+      "reviewer",
+      "critic_oversight",
+      "explorer",
+      "coder",
+      "test_engineer",
+      "researcher"
+    ]
+  },
+  batch_symbols: {
+    description: "Batched symbol extraction across multiple files. Returns per-file symbol summaries with isolated error handling.",
+    agents: [
+      "architect",
+      "critic_hallucination_verifier",
+      "reviewer",
+      "critic_oversight",
+      "explorer"
+    ]
+  },
+  suggest_patch: {
+    description: "Reviewer-safe structured patch suggestion tool. Produces context-anchored patch artifacts without file modification. Returns structured diagnostics on context mismatch.",
+    agents: ["architect", "reviewer"]
+  },
+  req_coverage: {
+    description: "query requirement coverage status for tracked functional requirements",
+    agents: [
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "spec_writer",
+      "critic",
+      "critic_oversight"
+    ]
+  },
+  get_approved_plan: {
+    description: "retrieve the last critic-approved immutable plan snapshot for baseline drift comparison",
+    agents: ["critic_drift_verifier", "critic", "critic_oversight"]
+  },
+  repo_map: {
+    description: "query the repo code graph: importers, dependencies, blast radius, localization, ontology facts, package boundaries, and heuristic preflight packets before refactoring; ontology findings are advisory, not formal proofs",
+    agents: [
+      "architect",
+      "critic_sounding_board",
+      "critic_drift_verifier",
+      "critic_hallucination_verifier",
+      "critic_architecture_supervisor",
+      "reviewer",
+      "critic",
+      "critic_oversight",
+      "explorer",
+      "coder"
+    ]
+  },
+  get_qa_gate_profile: {
+    description: "retrieve the QA gate profile for the current plan: gates (reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, phase_council, drift_check, final_council), lock state, and profile hash. Read-only.",
+    agents: ["architect"]
+  },
+  set_qa_gates: {
+    description: "configure the QA gate profile for the current plan. Architect-only. Ratchet-tighter only \u2014 rejected once the profile is locked after critic approval. Supports: reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, phase_council, drift_check, final_council.",
+    agents: ["architect"]
+  },
+  web_search: {
+    description: "External web search (Tavily or Brave) for architect-driven council research, SME domain research, researcher auto-research, and skill-improver research. Returns titled results with snippets, URLs, normalized query metadata, temporal intent, freshness, and removed stale years. Config-gated on council.general.enabled in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project .opencode/opencode-swarm.json overrides. Requires a search API key. Used by the architect in MODE: COUNCIL to gather a RESEARCH CONTEXT before dispatching council agents, by SME for opt-in external skill/source evaluation, and by the researcher agent for multi-source auto-research.",
+    agents: ["sme", "researcher", "skill_improver"]
+  },
+  web_fetch: {
+    description: "Fetch the readable text of a single http(s) URL (architect-only). Returns decoded page text, document title, final URL after redirects, and an evidence reference. Reads primary sources that web_search only surfaces as snippets. Config-gated on council.general.enabled. Blocks private/loopback/link-local/metadata addresses (re-validated and re-pinned across redirects); enforces timeout and body size cap.",
+    agents: []
+  },
+  convene_general_council: {
+    description: "Synthesize responses from a multi-model General Council. Accepts parallel member responses (Round 1, optionally Round 2), detects disagreements, and returns consensus points, persisting disagreements, and a structured synthesis. Architect-only. Config-gated on council.general.enabled in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project .opencode/opencode-swarm.json overrides.",
+    agents: []
+  },
+  write_final_council_evidence: {
+    description: "Persist project-scoped final council evidence to .swarm/evidence/final-council.json. PREREQUISITE: dispatch critic, reviewer, sme, test_engineer, and explorer as project-scoped Agent tasks and collect their CouncilMemberVerdict JSON \u2014 this tool synthesizes only. Rejects on insufficient quorum or CONCERNS with unresolved requiredFixes; normalizes verdicts to approved/concerns/rejected. Architect-only.",
+    agents: []
+  },
+  skill_generate: {
+    description: "compile knowledge entries into a structured SKILL.md draft",
+    agents: ["architect", "skill_improver"]
+  },
+  skill_list: {
+    description: "list generated skill files and their status",
+    agents: ["architect", "skill_improver"]
+  },
+  skill_apply: {
+    description: "activate a draft skill proposal",
+    agents: ["architect"]
+  },
+  skill_inspect: {
+    description: "inspect the content and source entries of a skill file",
+    agents: ["architect", "skill_improver"]
+  },
+  skill_regenerate: {
+    description: "regenerate an active skill by re-clustering its source knowledge entries and updating the SKILL.md in place",
+    agents: ["architect"]
+  },
+  skill_retire: {
+    description: "retire a generated skill by adding a retired.marker file; retired skills are excluded from scoring and injection",
+    agents: ["architect"]
+  },
+  skill_improve: {
+    description: "run the skill_improver agent to review and refine skills",
+    agents: ["architect", "skill_improver"]
+  },
+  spec_write: {
+    description: "author or update .swarm/spec.md for the current project",
+    agents: ["spec_writer"]
+  },
+  knowledge_receipt: {
+    description: "file a receipt for retrieved knowledge (applied/ignored/contradicted + new lessons), recorded as immutable knowledge events",
+    agents: ["architect", "coder"]
+  },
+  knowledge_archive: {
+    description: "archive (default), quarantine, or purge a swarm or hive knowledge entry by ID with an immutable audit tombstone; purge requires an admin flag",
+    agents: ["architect"]
+  },
+  swarm_memory_recall: {
+    description: "recall scoped Swarm memory for the current repository as untrusted background",
+    agents: []
+  },
+  swarm_memory_propose: {
+    description: "create a pending Swarm memory proposal; does not write durable memory directly",
+    agents: []
+  },
+  swarm_command: {
+    description: "run supported /swarm commands through the canonical command registry",
+    agents: [
+      "architect",
+      "sme",
+      "researcher",
+      "docs",
+      "docs_design",
+      "designer",
+      "reviewer",
+      "critic",
+      "explorer",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  dispatch_lanes: {
+    description: "dispatch read-only exploration/review lanes concurrently and BLOCK until all finish; prefer dispatch_lanes_async for non-blocking dispatch, use this only when promptAsync is unavailable",
+    agents: ["architect"]
+  },
+  dispatch_lanes_async: {
+    description: "launch read-only advisory lanes non-blockingly and return a batch id immediately so you can keep working; join later with collect_lane_results",
+    agents: ["architect"]
+  },
+  collect_lane_results: {
+    description: "collect or poll results for a dispatch_lanes_async batch; this is the required join barrier for advisory lane workflows and does not advance workflow gates",
+    agents: ["architect"]
+  },
+  summarize_work: {
+    description: "emit a short structured summary of completed work (key decisions, assumptions, risks, constraints) at task completion; rolls up per phase for architecture-supervisor review. Advisory, never blocks.",
+    agents: [
+      "architect",
+      "sme",
+      "researcher",
+      "docs",
+      "docs_design",
+      "designer",
+      "explorer",
+      "coder",
+      "test_engineer"
+    ]
+  },
+  write_architecture_supervisor_evidence: {
+    description: "persist the architecture supervisor verdict for a phase (architect MUST dispatch critic_architecture_supervisor first and collect its JSON verdict; this tool persists only, it does not contact the supervisor)",
+    agents: ["architect"]
+  },
+  lean_turbo_plan_lanes: {
+    description: "partition phase tasks into parallel lanes based on file-scope conflicts for Lean Turbo execution",
+    agents: []
+  },
+  lean_turbo_acquire_locks: {
+    description: "acquire file locks for all files in a lane (all-or-nothing) before lane execution",
+    agents: []
+  },
+  lean_turbo_runner_status: {
+    description: "read Lean Turbo run state from .swarm/turbo-state.json",
+    agents: []
+  },
+  lean_turbo_review: {
+    description: "dispatch a read-only reviewer agent to evaluate a completed Lean Turbo phase",
+    agents: []
+  },
+  lean_turbo_run_phase: {
+    description: "Execute a phase using Lean Turbo parallel lane execution. Plans lanes, acquires file locks, and dispatches coder agents concurrently. Use when Lean Turbo is active and you want to execute all tasks in a phase in parallel lanes.",
+    agents: []
+  },
+  lean_turbo_status: {
+    description: "returns Lean Turbo configuration and active status for the current session",
+    agents: []
+  },
+  apply_patch: {
+    description: "Apply a unified diff patch to workspace files with exact context matching, atomic writes, and path validation",
+    agents: ["coder", "test_engineer"]
+  },
+  external_skill_discover: {
+    description: "Discover external skill candidates from configured sources. Returns a disabled message when external_skills.curation_enabled is false.",
+    agents: []
+  },
+  external_skill_list: {
+    description: "List external skill candidates in the quarantine store. Returns a disabled message when external_skills.curation_enabled is false.",
+    agents: []
+  },
+  external_skill_inspect: {
+    description: "Inspect a specific external skill candidate by ID. Returns a disabled message when external_skills.curation_enabled is false.",
+    agents: []
+  },
+  external_skill_promote: {
+    description: "Promote a validated external skill candidate to an active generated skill. Returns a disabled message when external_skills.curation_enabled is false.",
+    agents: []
+  },
+  external_skill_reject: {
+    description: "Reject an external skill candidate after evaluation. Returns a disabled message when external_skills.curation_enabled is false.",
+    agents: []
+  },
+  external_skill_delete: {
+    description: "Delete an external skill candidate from the quarantine store. Returns a disabled message when external_skills.curation_enabled is false.",
+    agents: []
+  },
+  external_skill_revoke: {
+    description: "Revoke a previously promoted external skill. Returns a disabled message when external_skills.curation_enabled is false.",
+    agents: []
+  }
+};
+var TOOL_NAMES = Object.keys(TOOL_METADATA);
+var TOOL_NAME_SET = new Set(TOOL_NAMES);
+var TOOL_DESCRIPTIONS = Object.fromEntries(Object.entries(TOOL_METADATA).map(([name, meta]) => [
+  name,
+  meta.description
+]));
+var AGENT_TOOL_MAP = (() => {
+  const map = Object.fromEntries(ALL_AGENT_NAMES.map((agent) => [agent, []]));
+  for (const [name, meta] of Object.entries(TOOL_METADATA)) {
+    for (const agent of meta.agents) {
+      map[agent].push(name);
+    }
+  }
+  return map;
+})();
+// src/config/constants.ts
+var OPENCODE_NATIVE_AGENTS = new Set([
+  "build",
+  "plan",
+  "general",
+  "explore",
+  "compaction",
+  "title",
+  "summary"
+]);
+function freezeSet(items) {
+  const set = new Set(items);
+  const proxy = new Proxy(set, {
+    get(target, prop) {
+      if (prop === "add" || prop === "delete" || prop === "clear") {
+        return () => {
+          throw new TypeError("CLAUDE_CODE_NATIVE_COMMANDS is readonly");
+        };
+      }
+      if (prop === "forEach") {
+        return (callback, thisArg) => {
+          const wrapped = (v, k) => callback.call(thisArg ?? undefined, v, k, proxy);
+          return set.forEach(wrapped);
+        };
+      }
+      const value = Reflect.get(target, prop);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    set() {
+      throw new TypeError("CLAUDE_CODE_NATIVE_COMMANDS is readonly");
+    },
+    deleteProperty() {
+      throw new TypeError("CLAUDE_CODE_NATIVE_COMMANDS is readonly");
+    },
+    defineProperty() {
+      throw new TypeError("CLAUDE_CODE_NATIVE_COMMANDS is readonly");
+    },
+    setPrototypeOf() {
+      throw new TypeError("CLAUDE_CODE_NATIVE_COMMANDS is readonly");
+    }
+  });
+  return proxy;
+}
+var CLAUDE_CODE_NATIVE_COMMANDS = freezeSet([
+  "clear",
+  "new",
+  "reset",
+  "resume",
+  "continue",
+  "exit",
+  "quit",
+  "compact",
+  "fork",
+  "branch",
+  "undo",
+  "checkpoint",
+  "rewind",
+  "rename",
+  "doctor",
+  "help",
+  "status",
+  "statusline",
+  "cost",
+  "usage",
+  "stats",
+  "context",
+  "debug",
+  "insights",
+  "recap",
+  "release-notes",
+  "heapdump",
+  "powerup",
+  "config",
+  "settings",
+  "model",
+  "effort",
+  "fast",
+  "theme",
+  "color",
+  "keybindings",
+  "privacy-settings",
+  "init",
+  "focus",
+  "sandbox",
+  "terminal-setup",
+  "permissions",
+  "allowed-tools",
+  "security-review",
+  "fewer-permission-prompts",
+  "plugin",
+  "reload-plugins",
+  "hooks",
+  "mcp",
+  "ide",
+  "chrome",
+  "desktop",
+  "app",
+  "mobile",
+  "ios",
+  "android",
+  "remote-control",
+  "rc",
+  "remote-env",
+  "login",
+  "logout",
+  "review",
+  "pr-comments",
+  "agents",
+  "batch",
+  "loop",
+  "proactive",
+  "claude-api",
+  "schedule",
+  "routines",
+  "autofix-pr",
+  "plan",
+  "diff",
+  "export",
+  "copy",
+  "feedback",
+  "bug",
+  "btw",
+  "add-dir",
+  "memory",
+  "skills",
+  "upgrade",
+  "vim",
+  "voice",
+  "extra-usage",
+  "install-github-app",
+  "install-slack-app",
+  "passes",
+  "setup-bedrock",
+  "install",
+  "tasks",
+  "history",
+  "term",
+  "teleport",
+  "ultrareview",
+  "ultraplan",
+  "web-setup",
+  "setup-vertex",
+  "tui",
+  "simplify",
+  "summary",
+  "stickers",
+  "tp",
+  "team-onboarding",
+  "bashes"
+]);
+var EXTERNAL_SKILL_TOOL_NAMES = [
+  "external_skill_discover",
+  "external_skill_list",
+  "external_skill_inspect",
+  "external_skill_promote",
+  "external_skill_reject",
+  "external_skill_delete",
+  "external_skill_revoke"
+];
+var EXTERNAL_SKILL_AGENT_TOOL_MAP = {
+  architect: [...EXTERNAL_SKILL_TOOL_NAMES]
+};
+var COUNCIL_TOOL_NAMES = [
+  "submit_council_verdicts",
+  "submit_phase_council_verdicts",
+  "declare_council_criteria",
+  "write_final_council_evidence"
+];
+var COUNCIL_AGENT_TOOL_MAP = {
+  architect: [...COUNCIL_TOOL_NAMES]
+};
+var GENERAL_COUNCIL_TOOL_NAMES = [
+  "convene_general_council",
+  "web_search",
+  "web_fetch"
+];
+var GENERAL_COUNCIL_AGENT_TOOL_MAP = {
+  architect: [...GENERAL_COUNCIL_TOOL_NAMES]
+};
+var TURBO_TOOL_NAMES = [
+  "lean_turbo_plan_lanes",
+  "lean_turbo_acquire_locks",
+  "lean_turbo_runner_status",
+  "lean_turbo_review",
+  "lean_turbo_run_phase",
+  "lean_turbo_status"
+];
+var TURBO_AGENT_TOOL_MAP = {
+  architect: [...TURBO_TOOL_NAMES]
+};
+var DEFAULT_AGENT_CONFIGS = {
+  coder: {
+    model: "opencode/minimax-m2.5-free",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  reviewer: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  test_engineer: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  explorer: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  sme: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  researcher: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  critic: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  docs: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  docs_design: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  designer: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+  },
+  critic_sounding_board: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  critic_drift_verifier: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  critic_hallucination_verifier: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  critic_oversight: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  critic_architecture_supervisor: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano"]
+  },
+  curator_init: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  curator_phase: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  curator_postmortem: {
+    model: "opencode/gpt-5-nano",
+    fallback_models: ["opencode/big-pickle"]
+  },
+  skill_improver: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano"]
+  },
+  spec_writer: {
+    model: "opencode/big-pickle",
+    fallback_models: ["opencode/gpt-5-nano"]
+  }
+};
+
+// src/config/schema.ts
+var _internals = {
+  stripKnownSwarmPrefix,
+  getCanonicalAgentRole,
+  resolveGuardrailsConfig
+};
+var SEPARATORS = ["_", "-", " "];
+var CANONICAL_ROLES_LONGEST_FIRST = [
+  ...ALL_AGENT_NAMES
+].sort((a, b) => b.length - a.length);
+var CANONICAL_ROLES_SET = new Set(ALL_AGENT_NAMES);
+function isKnownCanonicalRole(role) {
+  if (!role)
+    return false;
+  return CANONICAL_ROLES_SET.has(role);
+}
+function getCanonicalAgentRole(agentName, generatedAgentNames) {
+  if (!agentName)
+    return agentName;
+  const normalized = agentName.toLowerCase();
+  if (CANONICAL_ROLES_SET.has(normalized)) {
+    return normalized;
+  }
+  if (generatedAgentNames) {
+    const registry = new Set;
+    for (const n of generatedAgentNames)
+      registry.add(n.toLowerCase());
+    if (!registry.has(normalized)) {
+      return agentName;
+    }
+  }
+  for (const role of CANONICAL_ROLES_LONGEST_FIRST) {
+    for (const sep of SEPARATORS) {
+      const suffix = sep + role;
+      if (normalized.endsWith(suffix)) {
+        return role;
+      }
+    }
+  }
+  return agentName;
+}
+function resolveGeneratedAgentRole(agentName, generatedAgentNames) {
+  return _internals.getCanonicalAgentRole(agentName, generatedAgentNames);
+}
+function stripKnownSwarmPrefix(agentName) {
+  return getCanonicalAgentRole(agentName);
+}
+var AgentReasoningConfigSchema = exports_external.object({
+  effort: exports_external.enum(["low", "medium", "high", "max"]).optional()
+});
+var AgentThinkingConfigSchema = exports_external.object({
+  type: exports_external.enum(["enabled", "disabled"]).optional(),
+  budget_tokens: exports_external.number().int().positive().optional()
+});
+var AgentOverrideConfigSchema = exports_external.object({
+  model: exports_external.string().optional(),
+  variant: exports_external.string().min(1).optional(),
+  temperature: exports_external.number().min(0).max(2).optional(),
+  disabled: exports_external.boolean().optional(),
+  fallback_models: exports_external.array(exports_external.string()).max(3).optional(),
+  reasoning: AgentReasoningConfigSchema.optional(),
+  thinking: AgentThinkingConfigSchema.optional()
+});
+var SwarmConfigSchema = exports_external.object({
+  name: exports_external.string().optional(),
+  agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional()
+});
+var HooksConfigSchema = exports_external.object({
+  system_enhancer: exports_external.boolean().default(true),
+  compaction: exports_external.boolean().default(true),
+  agent_activity: exports_external.boolean().default(true),
+  delegation_tracker: exports_external.boolean().default(false),
+  agent_awareness_max_chars: exports_external.number().min(50).max(2000).default(300),
+  delegation_gate: exports_external.boolean().default(true),
+  delegation_max_chars: exports_external.number().min(500).max(20000).default(4000),
+  background_subagents: exports_external.boolean().default(false),
+  background_pending_timeout_minutes: exports_external.number().int().min(1).max(1440).default(30)
+});
+var ScoringWeightsSchema = exports_external.object({
+  phase: exports_external.number().min(0).max(5).default(1),
+  current_task: exports_external.number().min(0).max(5).default(2),
+  blocked_task: exports_external.number().min(0).max(5).default(1.5),
+  recent_failure: exports_external.number().min(0).max(5).default(2.5),
+  recent_success: exports_external.number().min(0).max(5).default(0.5),
+  evidence_presence: exports_external.number().min(0).max(5).default(1),
+  decision_recency: exports_external.number().min(0).max(5).default(1.5),
+  dependency_proximity: exports_external.number().min(0).max(5).default(1)
+});
+var DecisionDecaySchema = exports_external.object({
+  mode: exports_external.enum(["linear", "exponential"]).default("exponential"),
+  half_life_hours: exports_external.number().min(1).max(168).default(24)
+});
+var TokenRatiosSchema = exports_external.object({
+  prose: exports_external.number().min(0.1).max(1).default(0.25),
+  code: exports_external.number().min(0.1).max(1).default(0.4),
+  markdown: exports_external.number().min(0.1).max(1).default(0.3),
+  json: exports_external.number().min(0.1).max(1).default(0.35)
+});
+var ScoringConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  max_candidates: exports_external.number().min(10).max(500).default(100),
+  weights: ScoringWeightsSchema.optional(),
+  decision_decay: DecisionDecaySchema.optional(),
+  token_ratios: TokenRatiosSchema.optional()
+});
+var ContextBudgetConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  warn_threshold: exports_external.number().min(0).max(1).default(0.7),
+  critical_threshold: exports_external.number().min(0).max(1).default(0.9),
+  model_limits: exports_external.record(exports_external.string(), exports_external.number().min(1000)).default({ default: 128000 }),
+  max_injection_tokens: exports_external.number().min(100).max(50000).default(4000),
+  tracked_agents: exports_external.array(exports_external.string()).default(["architect"]),
+  scoring: ScoringConfigSchema.optional(),
+  enforce: exports_external.boolean().default(true),
+  prune_target: exports_external.number().min(0).max(1).default(0.7),
+  preserve_last_n_turns: exports_external.number().min(0).max(100).default(4),
+  recent_window: exports_external.number().min(1).max(100).default(10),
+  enforce_on_agent_switch: exports_external.boolean().default(true),
+  tool_output_mask_threshold: exports_external.number().min(100).max(1e5).default(2000)
+});
+var EvidenceConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  max_age_days: exports_external.number().min(1).max(365).default(90),
+  max_bundles: exports_external.number().min(10).max(1e4).default(1000),
+  auto_archive: exports_external.boolean().default(false)
+});
+var GateFeatureSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true)
+});
+var PlaceholderScanConfigSchema = GateFeatureSchema.extend({
+  deny_patterns: exports_external.array(exports_external.string()).default([
+    "TODO",
+    "FIXME",
+    "TBD",
+    "XXX",
+    "placeholder",
+    "stub",
+    "wip",
+    "not implemented"
+  ]),
+  allow_globs: exports_external.array(exports_external.string()).default([
+    "docs/**",
+    "examples/**",
+    "tests/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/mocks/**",
+    "**/__tests__/**"
+  ]),
+  max_allowed_findings: exports_external.number().min(0).default(0)
+});
+var QualityBudgetConfigSchema = GateFeatureSchema.extend({
+  max_complexity_delta: exports_external.number().default(5),
+  max_public_api_delta: exports_external.number().default(10),
+  max_duplication_ratio: exports_external.number().default(0.05),
+  min_test_to_code_ratio: exports_external.number().default(0.3),
+  enforce_on_globs: exports_external.array(exports_external.string()).default(["src/**"]),
+  exclude_globs: exports_external.array(exports_external.string()).default(["docs/**", "tests/**", "**/*.test.*"])
+});
+var GateConfigSchema = exports_external.object({
+  syntax_check: GateFeatureSchema.default({ enabled: true }),
+  placeholder_scan: PlaceholderScanConfigSchema.default({
+    enabled: true,
+    deny_patterns: [
+      "TODO",
+      "FIXME",
+      "TBD",
+      "XXX",
+      "placeholder",
+      "stub",
+      "wip",
+      "not implemented"
+    ],
+    allow_globs: [
+      "docs/**",
+      "examples/**",
+      "tests/**",
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/mocks/**",
+      "**/__tests__/**"
+    ],
+    max_allowed_findings: 0
+  }),
+  sast_scan: GateFeatureSchema.default({ enabled: true }),
+  sbom_generate: GateFeatureSchema.default({ enabled: true }),
+  build_check: GateFeatureSchema.default({ enabled: true }),
+  quality_budget: QualityBudgetConfigSchema
+});
+var PipelineConfigSchema = exports_external.object({
+  parallel_precheck: exports_external.boolean().default(true)
+});
+var PhaseCompleteConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  required_agents: exports_external.array(exports_external.enum(["coder", "reviewer", "test_engineer"])).default(["coder", "reviewer", "test_engineer"]),
+  require_docs: exports_external.boolean().default(true),
+  policy: exports_external.enum(["enforce", "warn"]).default("enforce"),
+  regression_sweep: exports_external.object({
+    enforce: exports_external.boolean().default(false)
+  }).optional()
+});
+var SummaryConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  threshold_bytes: exports_external.number().min(1024).max(1048576).default(16384),
+  max_summary_chars: exports_external.number().min(100).max(5000).default(1000),
+  max_stored_bytes: exports_external.number().min(10240).max(104857600).default(10485760),
+  retention_days: exports_external.number().min(1).max(365).default(7),
+  exempt_tools: exports_external.array(exports_external.string()).default(["retrieve_summary", "task", "read"])
+});
+var ReviewPassesConfigSchema = exports_external.object({
+  always_security_review: exports_external.boolean().default(false),
+  security_globs: exports_external.array(exports_external.string()).default([
+    "**/auth/**",
+    "**/api/**",
+    "**/crypto/**",
+    "**/security/**",
+    "**/middleware/**",
+    "**/session/**",
+    "**/token/**"
+  ])
+});
+var AutoReviewConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  trigger: exports_external.enum(["task_completion", "phase_boundary", "both"]).default("phase_boundary"),
+  timeout_ms: exports_external.number().int().min(1e4).max(1800000).default(300000),
+  max_diff_kb: exports_external.number().int().min(16).max(2048).default(256)
+});
+var AdversarialDetectionConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  policy: exports_external.enum(["warn", "gate", "ignore"]).default("warn"),
+  pairs: exports_external.array(exports_external.tuple([exports_external.string(), exports_external.string()])).default([["coder", "reviewer"]])
+});
+var AdversarialTestingConfigSchemaBase = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  scope: exports_external.enum(["all", "security-only"]).default("all")
+});
+var AdversarialTestingConfigSchema = AdversarialTestingConfigSchemaBase.default(() => ({
+  enabled: true,
+  scope: "all"
+}));
+var IntegrationAnalysisConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true)
+});
+var DocsConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  doc_patterns: exports_external.array(exports_external.string()).default([
+    "README.md",
+    "CONTRIBUTING.md",
+    "docs/**/*.md",
+    "docs/**/*.rst",
+    "**/CHANGELOG.md"
+  ])
+});
+var DesignDocsConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  out_dir: exports_external.string().default("docs").refine((v) => v.length > 0 && v !== "." && !v.includes("..") && !v.startsWith("/") && !v.startsWith("\\") && !/^[A-Za-z]:/.test(v), {
+    message: 'design_docs.out_dir must be a non-empty project-relative path with no "..", leading slash, or drive letter'
+  }),
+  language: exports_external.string().optional()
+});
+var UIReviewConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  trigger_paths: exports_external.array(exports_external.string()).default([
+    "**/pages/**",
+    "**/components/**",
+    "**/views/**",
+    "**/screens/**",
+    "**/ui/**",
+    "**/layouts/**"
+  ]),
+  trigger_keywords: exports_external.array(exports_external.string()).default([
+    "new page",
+    "new screen",
+    "new component",
+    "redesign",
+    "layout change",
+    "form",
+    "modal",
+    "dialog",
+    "dropdown",
+    "sidebar",
+    "navbar",
+    "dashboard",
+    "landing page",
+    "signup",
+    "login form",
+    "settings page",
+    "profile page"
+  ])
+});
+var CompactionAdvisoryConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  thresholds: exports_external.array(exports_external.number().int().min(10).max(500)).default([50, 75, 100, 125, 150]),
+  message: exports_external.string().default("[SWARM HINT] Session has " + "$" + "{totalToolCalls} tool calls. Consider compacting at next phase boundary to maintain context quality.")
+});
+var LintConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  mode: exports_external.enum(["check", "fix"]).default("check"),
+  linter: exports_external.enum(["biome", "eslint", "auto"]).default("auto"),
+  patterns: exports_external.array(exports_external.string()).default([
+    "**/*.{ts,tsx,js,jsx,mjs,cjs}",
+    "**/biome.json",
+    "**/biome.jsonc"
+  ]),
+  exclude: exports_external.array(exports_external.string()).default([
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/.git/**",
+    "**/coverage/**",
+    "**/*.min.js"
+  ])
+});
+var SecretscanConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  patterns: exports_external.array(exports_external.string()).default([
+    "**/*.{env,properties,yml,yaml,json,js,ts}",
+    "**/.env*",
+    "**/secrets/**",
+    "**/credentials/**",
+    "**/config/**/*.ts",
+    "**/config/**/*.js"
+  ]),
+  exclude: exports_external.array(exports_external.string()).default([
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/.git/**",
+    "**/coverage/**",
+    "**/test/**",
+    "**/tests/**",
+    "**/__tests__/**",
+    "**/*.test.ts",
+    "**/*.test.js",
+    "**/*.spec.ts",
+    "**/*.spec.js"
+  ]),
+  extensions: exports_external.array(exports_external.string()).default([
+    ".env",
+    ".properties",
+    ".yml",
+    ".yaml",
+    ".json",
+    ".js",
+    ".ts",
+    ".py",
+    ".rb",
+    ".go",
+    ".java",
+    ".cs",
+    ".php"
+  ])
+});
+var GuardrailsProfileSchema = exports_external.object({
+  max_tool_calls: exports_external.number().min(0).max(1000).optional(),
+  max_duration_minutes: exports_external.number().min(0).max(480).optional(),
+  max_repetitions: exports_external.number().min(3).max(50).optional(),
+  max_consecutive_errors: exports_external.number().min(2).max(20).optional(),
+  warning_threshold: exports_external.number().min(0.1).max(0.9).optional(),
+  idle_timeout_minutes: exports_external.number().min(5).max(240).optional(),
+  max_transient_retries: exports_external.number().min(0).max(20).optional()
+});
+var DEFAULT_AGENT_PROFILES = {
+  architect: {
+    max_tool_calls: 0,
+    max_duration_minutes: 0,
+    max_consecutive_errors: 8,
+    warning_threshold: 0.75
+  },
+  coder: {
+    max_tool_calls: 400,
+    max_duration_minutes: 45,
+    max_consecutive_errors: 8,
+    warning_threshold: 0.85
+  },
+  test_engineer: {
+    max_tool_calls: 400,
+    max_duration_minutes: 45,
+    max_consecutive_errors: 8,
+    warning_threshold: 0.85
+  },
+  explorer: {
+    max_tool_calls: 150,
+    max_duration_minutes: 20,
+    max_consecutive_errors: 8,
+    warning_threshold: 0.75
+  },
+  reviewer: {
+    max_tool_calls: 200,
+    max_duration_minutes: 30,
+    max_consecutive_errors: 8,
+    warning_threshold: 0.65
+  },
+  critic: {
+    max_tool_calls: 200,
+    max_duration_minutes: 30,
+    warning_threshold: 0.65
+  },
+  sme: {
+    max_tool_calls: 200,
+    max_duration_minutes: 30,
+    warning_threshold: 0.65
+  },
+  docs: {
+    max_tool_calls: 200,
+    max_duration_minutes: 30,
+    warning_threshold: 0.75
+  },
+  designer: {
+    max_tool_calls: 150,
+    max_duration_minutes: 20,
+    warning_threshold: 0.75
+  }
+};
+var DEFAULT_ARCHITECT_PROFILE = DEFAULT_AGENT_PROFILES.architect;
+var GuardrailsConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  max_tool_calls: exports_external.number().min(0).max(1000).default(200),
+  max_duration_minutes: exports_external.number().min(0).max(480).default(30),
+  max_repetitions: exports_external.number().min(3).max(50).default(10),
+  max_consecutive_errors: exports_external.number().min(2).max(20).default(5),
+  max_transient_retries: exports_external.number().min(0).max(20).default(5),
+  warning_threshold: exports_external.number().min(0.1).max(0.9).default(0.75),
+  idle_timeout_minutes: exports_external.number().min(5).max(240).default(60),
+  no_op_warning_threshold: exports_external.number().min(1).max(100).default(15),
+  max_coder_revisions: exports_external.number().int().min(1).max(20).default(5),
+  runaway_output_max_turns: exports_external.number().int().min(1).max(20).default(5),
+  qa_gates: exports_external.object({
+    required_tools: exports_external.array(exports_external.string().min(1)).default([
+      "diff",
+      "syntax_check",
+      "placeholder_scan",
+      "lint",
+      "pre_check_batch"
+    ]),
+    require_reviewer_test_engineer: exports_external.boolean().default(true)
+  }).optional(),
+  profiles: exports_external.record(exports_external.string(), GuardrailsProfileSchema).optional(),
+  block_destructive_commands: exports_external.boolean().default(true),
+  interpreter_allowed_agents: exports_external.array(exports_external.string().min(1)).optional(),
+  shell_audit_log: exports_external.boolean().default(true)
+});
+var WatchdogConfigSchema = exports_external.object({
+  scope_guard: exports_external.boolean().default(true),
+  skip_in_turbo: exports_external.boolean().default(false),
+  delegation_ledger: exports_external.boolean().default(true)
+});
+var SelfReviewConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  skip_in_turbo: exports_external.boolean().default(true)
+});
+function resolveGuardrailsConfig(config, agentName) {
+  if (!agentName) {
+    return config;
+  }
+  const canonicalName = _internals.stripKnownSwarmPrefix(agentName);
+  const hasBuiltInProfile = canonicalName in DEFAULT_AGENT_PROFILES;
+  const userProfile = config.profiles?.[agentName] ?? config.profiles?.[canonicalName];
+  if (!hasBuiltInProfile) {
+    if (userProfile) {
+      return { ...config, ...userProfile };
+    }
+    return config;
+  }
+  const builtInProfile = DEFAULT_AGENT_PROFILES[canonicalName];
+  const resolved = {
+    ...config,
+    ...builtInProfile,
+    ...userProfile || {}
+  };
+  return resolved;
+}
+var ToolFilterConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  overrides: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).default({})
+});
+var PlanCursorConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  max_tokens: exports_external.number().min(500).max(4000).default(1500),
+  lookahead_tasks: exports_external.number().min(0).max(5).default(2)
+});
+var ContextMapConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  mode: exports_external.enum(["conservative", "balanced", "aggressive"]).default("balanced"),
+  max_capsule_tokens: exports_external.number().int().positive().default(2000),
+  invalidate_on_hash_change: exports_external.boolean().default(true),
+  agent_profiles: exports_external.record(exports_external.string(), exports_external.string()).default({})
+});
+var RepoGraphConfigSchema = exports_external.object({
+  exclude_dirs: exports_external.array(exports_external.string().trim().min(1)).default([])
+});
+var CheckpointConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  auto_checkpoint_threshold: exports_external.number().int().min(1).max(20).default(3),
+  allow_empty_commits: exports_external.boolean().default(false)
+}).strict();
+var AutomationModeSchema = exports_external.enum(["manual", "hybrid", "auto"]);
+var AutomationCapabilitiesSchema = exports_external.object({
+  plan_sync: exports_external.boolean().default(true),
+  phase_preflight: exports_external.boolean().default(false),
+  config_doctor_on_startup: exports_external.boolean().default(false),
+  config_doctor_autofix: exports_external.boolean().default(false),
+  evidence_auto_summaries: exports_external.boolean().default(true),
+  decision_drift_detection: exports_external.boolean().default(true)
+});
+var AutomationConfigSchemaBase = exports_external.object({
+  mode: AutomationModeSchema.default("manual"),
+  capabilities: AutomationCapabilitiesSchema.default({
+    plan_sync: true,
+    phase_preflight: false,
+    config_doctor_on_startup: false,
+    config_doctor_autofix: false,
+    evidence_auto_summaries: true,
+    decision_drift_detection: true
+  })
+});
+var AutomationConfigSchema = AutomationConfigSchemaBase;
+var KnowledgeConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  swarm_max_entries: exports_external.number().min(1).max(1e4).default(100),
+  hive_max_entries: exports_external.number().min(1).max(1e5).default(200),
+  auto_promote_days: exports_external.number().min(1).max(3650).default(90),
+  max_inject_count: exports_external.number().min(0).max(50).default(5),
+  delegate_max_inject_count: exports_external.number().min(0).max(50).default(8),
+  inject_char_budget: exports_external.number().min(200).max(1e4).default(2000),
+  context_budget_threshold: exports_external.number().int().positive().optional(),
+  max_lesson_display_chars: exports_external.number().min(40).max(280).default(120),
+  dedup_threshold: exports_external.number().min(0).max(1).default(0.6),
+  scope_filter: exports_external.array(exports_external.string()).default(["global"]),
+  hive_enabled: exports_external.boolean().default(true),
+  rejected_max_entries: exports_external.number().min(1).max(1000).default(20),
+  validation_enabled: exports_external.boolean().default(true),
+  evergreen_confidence: exports_external.number().min(0).max(1).default(0.9),
+  evergreen_utility: exports_external.number().min(0).max(1).default(0.8),
+  low_utility_threshold: exports_external.number().min(0).max(1).default(0.3),
+  min_retrievals_for_utility: exports_external.number().min(1).max(100).default(3),
+  schema_version: exports_external.number().int().min(1).default(1),
+  directive_min_confidence: exports_external.number().min(0).max(1).default(0.75),
+  same_project_weight: exports_external.number().min(0).max(5).default(1),
+  cross_project_weight: exports_external.number().min(0).max(5).default(0.5),
+  min_encounter_score: exports_external.number().min(0).max(1).default(0.1),
+  initial_encounter_score: exports_external.number().min(0).max(5).default(1),
+  encounter_increment: exports_external.number().min(0).max(1).default(0.1),
+  max_encounter_score: exports_external.number().min(1).max(20).default(10),
+  default_max_phases: exports_external.number().int().positive().default(10),
+  todo_max_phases: exports_external.number().int().positive().default(3),
+  sweep_enabled: exports_external.boolean().default(true),
+  retrieval: exports_external.object({
+    mmr_lambda: exports_external.number().min(0).max(1).default(0.5),
+    cold_start_bonus: exports_external.number().min(0).max(0.5).default(0.08),
+    cold_start_max_age_phases: exports_external.number().int().min(0).max(100).default(3),
+    synonym_min_cooccurrence: exports_external.number().int().min(1).max(100).default(3),
+    synonym_map_max_pairs: exports_external.number().int().min(1).max(1e4).default(500)
+  }).optional(),
+  enrichment: exports_external.object({
+    max_calls_per_day: exports_external.number().int().min(0).max(1000).default(30),
+    quota_window: exports_external.enum(["utc", "local"]).default("utc"),
+    batch_size: exports_external.number().int().min(1).max(100).optional()
+  }).default({ max_calls_per_day: 30, quota_window: "utc" })
+});
+var MemoryConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  provider: exports_external.enum(["local-jsonl", "sqlite"]).default("sqlite"),
+  storageDir: exports_external.string().default(".swarm/memory"),
+  sqlite: exports_external.object({
+    path: exports_external.string().default(".swarm/memory/memory.db"),
+    busyTimeoutMs: exports_external.number().int().min(0).max(60000).default(5000)
+  }).default({ path: ".swarm/memory/memory.db", busyTimeoutMs: 5000 }),
+  recall: exports_external.object({
+    defaultMaxItems: exports_external.number().int().min(1).max(20).default(8),
+    defaultTokenBudget: exports_external.number().int().min(100).max(5000).default(1200),
+    minScore: exports_external.number().min(0).max(1).default(0.05),
+    injection: exports_external.object({
+      enabled: exports_external.boolean().default(true),
+      minScore: exports_external.number().min(0).max(1).default(0.25),
+      requireQuerySignal: exports_external.boolean().default(true),
+      maxItems: exports_external.number().int().min(1).max(20).default(6),
+      tokenBudget: exports_external.number().int().min(100).max(5000).default(1000)
+    }).default({
+      enabled: true,
+      minScore: 0.25,
+      requireQuerySignal: true,
+      maxItems: 6,
+      tokenBudget: 1000
+    })
+  }).default({
+    defaultMaxItems: 8,
+    defaultTokenBudget: 1200,
+    minScore: 0.05,
+    injection: {
+      enabled: true,
+      minScore: 0.25,
+      requireQuerySignal: true,
+      maxItems: 6,
+      tokenBudget: 1000
+    }
+  }),
+  writes: exports_external.object({
+    mode: exports_external.literal("propose").default("propose")
+  }).default({ mode: "propose" }),
+  redaction: exports_external.object({
+    rejectDurableSecrets: exports_external.boolean().default(true)
+  }).default({ rejectDurableSecrets: true }),
+  maintenance: exports_external.object({
+    lowUtilityMaxConfidence: exports_external.number().min(0).max(1).default(0.45),
+    lowUtilityMinAgeDays: exports_external.number().int().min(1).max(3650).default(30)
+  }).default({
+    lowUtilityMaxConfidence: 0.45,
+    lowUtilityMinAgeDays: 30
+  }),
+  hardDelete: exports_external.boolean().default(false)
+});
+var CuratorConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  init_enabled: exports_external.boolean().default(true),
+  phase_enabled: exports_external.boolean().default(true),
+  postmortem_enabled: exports_external.boolean().default(true),
+  max_summary_tokens: exports_external.number().min(500).max(8000).default(2000),
+  min_knowledge_confidence: exports_external.number().min(0).max(1).default(0.7),
+  compliance_report: exports_external.boolean().default(true),
+  suppress_warnings: exports_external.boolean().default(true),
+  drift_inject_max_chars: exports_external.number().min(100).max(2000).default(500),
+  llm_timeout_ms: exports_external.number().int().min(5000).max(600000).default(300000),
+  skill_generation_enabled: exports_external.boolean().default(true),
+  skill_generation_mode: exports_external.enum(["draft", "active"]).default("draft"),
+  min_skill_confidence: exports_external.number().min(0).max(1).default(0.7),
+  min_skill_confirmations: exports_external.number().int().min(1).max(50).default(2)
+});
+var ArchitecturalSupervisionConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  mode: exports_external.enum(["advisory", "gate"]).default("advisory"),
+  run_on: exports_external.enum(["phase_complete"]).default("phase_complete"),
+  summary_model: exports_external.string().min(1).optional(),
+  max_agent_summary_words: exports_external.number().int().min(20).max(500).default(100),
+  max_phase_summary_words: exports_external.number().int().min(50).max(1000).default(250),
+  allow_concerns_to_complete: exports_external.boolean().default(true),
+  persist_knowledge_recommendations: exports_external.boolean().default(false),
+  provenance_verify: exports_external.boolean().default(false)
+});
+var KnowledgeApplicationConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  mode: exports_external.enum(["warn", "enforce"]).default("warn"),
+  min_confidence: exports_external.number().min(0).max(1).default(0.85),
+  critical_requires_ack: exports_external.boolean().default(true),
+  require_skill_refs: exports_external.boolean().default(true),
+  high_risk_tools: exports_external.array(exports_external.string()).default([
+    "save_plan",
+    "update_task_status",
+    "phase_complete",
+    "task",
+    "Task"
+  ])
+});
+var SkillPropagationConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  enforce: exports_external.boolean().default(false)
+});
+var SkillImproverConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  model: exports_external.string().nullable().default(null),
+  fallback_models: exports_external.array(exports_external.string()).default([]),
+  max_calls_per_day: exports_external.number().int().min(1).max(1000).default(10),
+  trigger: exports_external.enum(["manual", "scheduled"]).default("manual"),
+  consolidation_interval_hours: exports_external.number().int().min(1).max(24 * 30).default(24),
+  consolidation_max_calls_per_run: exports_external.number().int().min(1).max(100).default(1),
+  targets: exports_external.array(exports_external.enum(["skills", "spec", "architect_prompt", "knowledge"])).default(["skills", "spec", "architect_prompt", "knowledge"]),
+  write_mode: exports_external.enum(["proposal", "draft_skills"]).default("proposal"),
+  require_user_approval: exports_external.boolean().default(true),
+  quota_window: exports_external.enum(["utc", "local"]).default("utc"),
+  allow_deterministic_fallback: exports_external.boolean().default(true)
+});
+var SpecWriterConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  model: exports_external.string().nullable().default(null),
+  fallback_models: exports_external.array(exports_external.string()).default([]),
+  allow_spec_write: exports_external.boolean().default(true)
+});
+var SlopDetectorConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  classThreshold: exports_external.number().int().min(1).default(3),
+  commentStripThreshold: exports_external.number().int().min(1).default(5),
+  diffLineThreshold: exports_external.number().int().min(10).default(200),
+  importHygieneThreshold: exports_external.number().int().min(1).default(2)
+});
+var IncrementalVerifyConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  command: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).nullable().default(null),
+  timeoutMs: exports_external.number().int().min(1000).max(300000).default(30000),
+  triggerAgents: exports_external.array(exports_external.string()).default(["coder"])
+});
+var CompactionConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  observationThreshold: exports_external.number().min(1).max(99).default(40),
+  reflectionThreshold: exports_external.number().min(1).max(99).default(60),
+  emergencyThreshold: exports_external.number().min(1).max(99).default(80),
+  preserveLastNTurns: exports_external.number().int().min(1).default(5)
+});
+var PrmConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  pattern_thresholds: exports_external.object({
+    repetition_loop: exports_external.number().min(1).default(2),
+    ping_pong: exports_external.number().min(1).default(2),
+    expansion_drift: exports_external.number().min(1).default(3),
+    stuck_on_test: exports_external.number().min(1).default(3),
+    context_thrash: exports_external.number().min(1).default(3)
+  }).default(() => ({
+    repetition_loop: 2,
+    ping_pong: 2,
+    expansion_drift: 3,
+    stuck_on_test: 3,
+    context_thrash: 3
+  })),
+  max_trajectory_lines: exports_external.number().min(10).default(1000),
+  escalation_enabled: exports_external.boolean().default(true),
+  detection_timeout_ms: exports_external.number().min(10).default(100)
+});
+var AgentAuthorityRuleSchema = exports_external.object({
+  readOnly: exports_external.boolean().optional(),
+  blockedExact: exports_external.array(exports_external.string()).optional(),
+  allowedExact: exports_external.array(exports_external.string()).optional(),
+  blockedPrefix: exports_external.array(exports_external.string()).optional(),
+  allowedPrefix: exports_external.array(exports_external.string()).optional(),
+  blockedZones: exports_external.array(exports_external.enum(["production", "test", "config", "generated", "docs", "build"])).optional(),
+  blockedGlobs: exports_external.array(exports_external.string()).optional(),
+  allowedGlobs: exports_external.array(exports_external.string()).optional(),
+  allowedCaseSensitiveGlobs: exports_external.array(exports_external.string()).optional()
+});
+var AuthorityConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  rules: exports_external.record(exports_external.string(), AgentAuthorityRuleSchema).default({}),
+  universal_deny_prefixes: exports_external.array(exports_external.string().min(1)).default([]),
+  verifier_config_paths: exports_external.array(exports_external.string()).optional().describe("Additional glob patterns for verifier config files that are merged into the architect agent's blockedGlobs at plugin init. Writes to matching files are blocked by the authority layer.")
+});
+var GeneralCouncilMemberConfigSchema = exports_external.object({
+  memberId: exports_external.string().min(1),
+  model: exports_external.string().min(1),
+  role: exports_external.enum([
+    "generalist",
+    "skeptic",
+    "domain_expert",
+    "devil_advocate",
+    "synthesizer"
+  ]),
+  persona: exports_external.string().optional()
+}).strict();
+var GeneralCouncilConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  searchProvider: exports_external.enum(["tavily", "brave"]).default("tavily"),
+  searchApiKey: exports_external.string().optional(),
+  members: exports_external.array(GeneralCouncilMemberConfigSchema).default([]),
+  presets: exports_external.record(exports_external.string(), exports_external.array(GeneralCouncilMemberConfigSchema)).default({}),
+  deliberate: exports_external.boolean().default(true),
+  moderator: exports_external.boolean().default(true),
+  moderatorModel: exports_external.string().optional(),
+  maxSourcesPerMember: exports_external.number().int().min(1).max(20).default(5)
+}).strict();
+var CouncilConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  maxRounds: exports_external.number().int().min(1).max(10).default(3),
+  parallelTimeoutMs: exports_external.number().int().min(5000).max(120000).default(30000),
+  vetoPriority: exports_external.boolean().default(true),
+  requireAllMembers: exports_external.boolean().default(false).describe("When true, submit_council_verdicts rejects if fewer than 5 member verdicts are provided. Equivalent to minimumMembers: 5."),
+  minimumMembers: exports_external.number().int().min(1).max(5).default(3).describe("Minimum distinct council member verdicts required for synthesis. Default 3. Set to 1 to disable quorum enforcement. requireAllMembers: true overrides this to 5 (stricter constraint wins)."),
+  escalateOnMaxRounds: exports_external.string().optional().describe("Optional webhook URL or handler name invoked when maxRounds is reached without APPROVE. Declared for forward compatibility; no behavior is implemented yet."),
+  phaseConcernsAllowComplete: exports_external.boolean().default(true).describe("When true, a phase-level council CONCERNS verdict with only MEDIUM/LOW findings does NOT block phase completion \u2014 the advisory notes are logged as warnings and the phase proceeds. When false, CONCERNS blocks like REJECT. Note: HIGH/CRITICAL findings from CONCERNS members are always promoted to requiredFixes and block at the tool level regardless of this setting. Default: true."),
+  general: GeneralCouncilConfigSchema.optional()
+}).strict();
+var PrMonitorConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  poll_interval_seconds: exports_external.number().int().min(30).max(300).default(60),
+  max_subscriptions: exports_external.number().int().min(1).max(100).default(20),
+  max_prs_per_cycle: exports_external.number().int().min(1).max(20).default(5),
+  max_concurrent_pr_polls: exports_external.number().int().min(1).max(10).default(3),
+  poll_timeout_ms: exports_external.number().int().min(5000).max(120000).default(30000),
+  failure_threshold: exports_external.number().int().min(1).max(20).default(5),
+  cooldown_seconds: exports_external.number().int().min(5).max(600).default(30),
+  max_cooldown_seconds: exports_external.number().int().min(30).max(3600).default(300),
+  cleanup_ttl_days: exports_external.number().int().min(1).max(90).default(7),
+  auto_unsubscribe_on_merge: exports_external.boolean().default(true),
+  auto_unsubscribe_on_close: exports_external.boolean().default(true),
+  notify_ci_failure: exports_external.boolean().default(true),
+  notify_new_comments: exports_external.boolean().default(true),
+  notify_merge_conflict: exports_external.boolean().default(true),
+  auto_pr_feedback: exports_external.boolean().default(false)
+}).strict();
+var ParallelizationConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  maxConcurrentTasks: exports_external.number().int().min(1).max(64).default(1),
+  evidenceLockTimeoutMs: exports_external.number().int().min(1000).max(300000).default(60000),
+  max_coders: exports_external.number().int().min(1).max(16).default(3),
+  max_reviewers: exports_external.number().int().min(1).max(16).default(2)
+});
+var WorktreeIsolationConfigSchema = exports_external.object({
+  policy: exports_external.enum(["auto", "required", "disabled"]).default("auto"),
+  merge_strategy: exports_external.enum(["merge", "rebase", "cherry-pick"]).default("merge"),
+  worktree_dir: exports_external.string().optional(),
+  deps_strategy: exports_external.enum(["skip", "copy", "link"]).default("skip")
+});
+var LeanTurboConfigSchema = exports_external.object({
+  max_parallel_coders: exports_external.number().int().min(1).max(6).default(4),
+  require_declared_scope: exports_external.boolean().default(true),
+  conflict_policy: exports_external.enum(["serialize", "degrade"]).default("serialize"),
+  degrade_on_risk: exports_external.boolean().default(true),
+  phase_reviewer: exports_external.boolean().default(true),
+  phase_critic: exports_external.boolean().default(true),
+  integrated_diff_required: exports_external.boolean().default(true),
+  allow_docs_only_without_reviewer: exports_external.boolean().default(false),
+  worktree_isolation: exports_external.boolean().default(false),
+  merge_strategy: exports_external.enum(["merge", "rebase", "cherry-pick"]).default("merge").optional(),
+  worktree_dir: exports_external.string().optional()
+});
+var StandardTurboConfigSchema = exports_external.object({
+  strategy: exports_external.literal("standard"),
+  lean: LeanTurboConfigSchema.optional()
+});
+var LeanTurboStrategyConfigSchema = exports_external.object({
+  strategy: exports_external.literal("lean"),
+  lean: LeanTurboConfigSchema
+});
+var TurboConfigSchema = exports_external.discriminatedUnion("strategy", [
+  StandardTurboConfigSchema,
+  LeanTurboStrategyConfigSchema
+]);
+var ExternalSkillCandidateSourceTypeSchema = exports_external.enum([
+  "github",
+  "url",
+  "collection",
+  "manual_import"
+]);
+var ExternalSkillCandidateEvaluationVerdictSchema = exports_external.enum([
+  "pending",
+  "in_review",
+  "quarantined",
+  "passed",
+  "rejected",
+  "promoted",
+  "revoked"
+]);
+var DiscoverySourceSchema = exports_external.object({
+  type: ExternalSkillCandidateSourceTypeSchema,
+  location: exports_external.string().min(1),
+  enabled: exports_external.boolean().default(true),
+  trust_level: exports_external.enum(["low", "medium", "high"]).default("low").optional()
+});
+var ExternalSkillCandidateSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  source_url: exports_external.string().url(),
+  source_type: ExternalSkillCandidateSourceTypeSchema,
+  publisher: exports_external.string().min(1),
+  sha256: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  fetched_at: exports_external.string().datetime(),
+  skill_name: exports_external.string().optional(),
+  skill_description: exports_external.string().optional(),
+  skill_body: exports_external.string(),
+  risk_flags: exports_external.array(exports_external.string()).default([]),
+  evaluation_verdict: ExternalSkillCandidateEvaluationVerdictSchema.default("pending"),
+  evaluation_history: exports_external.array(exports_external.object({
+    verdict: ExternalSkillCandidateEvaluationVerdictSchema,
+    timestamp: exports_external.string().datetime(),
+    actor: exports_external.string(),
+    reason: exports_external.string().optional(),
+    candidate_id: exports_external.string().optional(),
+    original_verdict: ExternalSkillCandidateEvaluationVerdictSchema.optional(),
+    gate_results: exports_external.array(exports_external.object({
+      gate: exports_external.string(),
+      verdict: exports_external.string()
+    })).optional(),
+    risk_assessment: exports_external.object({
+      total_flags: exports_external.number().int().nonnegative(),
+      findings: exports_external.array(exports_external.object({
+        severity: exports_external.enum(["error", "warning"]),
+        category: exports_external.string()
+      }))
+    }).optional(),
+    risk_flags_count: exports_external.number().int().nonnegative().optional(),
+    provenance_snapshot: exports_external.object({
+      sha256: exports_external.string(),
+      source_url: exports_external.string(),
+      publisher: exports_external.string(),
+      fetched_at: exports_external.string().datetime().optional()
+    }).optional(),
+    target_path: exports_external.string().optional(),
+    promoted_content_hash: exports_external.string().regex(/^[a-f0-9]{64}$/).optional(),
+    original_evaluation: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  })).default([])
+});
+var ExternalSkillsConfigSchema = exports_external.object({
+  curation_enabled: exports_external.boolean().default(false),
+  max_candidates: exports_external.number().int().min(1).max(1e4).default(500),
+  max_bytes_per_candidate: exports_external.number().int().min(1024).max(10485760).default(1048576),
+  eviction_policy: exports_external.enum(["fifo"]).default("fifo"),
+  ttl_days: exports_external.number().int().min(1).max(3650).default(90),
+  evaluation_enabled: exports_external.boolean().default(false),
+  sources: exports_external.array(DiscoverySourceSchema).default([]),
+  max_candidates_per_discovery: exports_external.number().int().min(1).max(1000).default(50),
+  max_concurrent_fetches: exports_external.number().int().min(1).max(20).default(5),
+  fetch_timeout_ms: exports_external.number().int().min(1000).max(300000).default(30000)
+});
+var DEFAULT_EXTERNAL_SKILLS_CONFIG = {
+  curation_enabled: false,
+  max_candidates: 500,
+  max_bytes_per_candidate: 1048576,
+  eviction_policy: "fifo",
+  ttl_days: 90,
+  evaluation_enabled: false,
+  sources: [],
+  max_candidates_per_discovery: 50,
+  max_concurrent_fetches: 5,
+  fetch_timeout_ms: 30000
+};
+function resolveExternalSkillsConfig(input) {
+  if (input === undefined || input === null || typeof input !== "object" || Array.isArray(input)) {
+    return { ...DEFAULT_EXTERNAL_SKILLS_CONFIG };
+  }
+  const config = input;
+  const merged = {
+    curation_enabled: config.curation_enabled ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.curation_enabled,
+    max_candidates: config.max_candidates ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.max_candidates,
+    max_bytes_per_candidate: config.max_bytes_per_candidate ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.max_bytes_per_candidate,
+    eviction_policy: config.eviction_policy ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.eviction_policy,
+    ttl_days: config.ttl_days ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.ttl_days,
+    evaluation_enabled: config.evaluation_enabled ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.evaluation_enabled,
+    sources: Array.isArray(config.sources) ? config.sources : [],
+    max_candidates_per_discovery: config.max_candidates_per_discovery ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.max_candidates_per_discovery,
+    max_concurrent_fetches: config.max_concurrent_fetches ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.max_concurrent_fetches,
+    fetch_timeout_ms: config.fetch_timeout_ms ?? DEFAULT_EXTERNAL_SKILLS_CONFIG.fetch_timeout_ms
+  };
+  return merged;
+}
+var PluginConfigSchema = exports_external.object({
+  agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
+  default_agent: exports_external.string().optional().transform((v) => {
+    if (v === undefined)
+      return;
+    const trimmed = v.trim();
+    return trimmed === "" ? undefined : trimmed;
+  }),
+  auto_select_architect: exports_external.union([exports_external.boolean(), exports_external.string()]).optional().transform((v) => {
+    if (v === undefined)
+      return;
+    if (typeof v === "boolean")
+      return v;
+    const trimmed = v.trim();
+    return trimmed === "" ? false : trimmed;
+  }),
+  swarms: exports_external.record(exports_external.string().regex(/^[^_]+$/, "Swarm ID must not contain underscores"), SwarmConfigSchema).optional(),
+  max_iterations: exports_external.number().min(1).max(10).default(5),
+  pipeline: PipelineConfigSchema.optional(),
+  phase_complete: PhaseCompleteConfigSchema.optional(),
+  qa_retry_limit: exports_external.number().min(1).max(10).default(3),
+  execution_mode: exports_external.enum(["strict", "balanced", "fast"]).default("balanced"),
+  inject_phase_reminders: exports_external.boolean().default(true),
+  hooks: HooksConfigSchema.optional(),
+  gates: GateConfigSchema.optional(),
+  context_budget: ContextBudgetConfigSchema.optional(),
+  guardrails: GuardrailsConfigSchema.optional(),
+  watchdog: WatchdogConfigSchema.optional(),
+  self_review: SelfReviewConfigSchema.optional(),
+  auto_review: AutoReviewConfigSchema.optional(),
+  tool_filter: ToolFilterConfigSchema.optional(),
+  authority: AuthorityConfigSchema.optional(),
+  plan_cursor: PlanCursorConfigSchema.optional(),
+  context_map: ContextMapConfigSchema.optional(),
+  repo_graph: RepoGraphConfigSchema.optional(),
+  evidence: EvidenceConfigSchema.optional(),
+  summaries: SummaryConfigSchema.optional(),
+  review_passes: ReviewPassesConfigSchema.optional(),
+  adversarial_detection: AdversarialDetectionConfigSchema.optional(),
+  adversarial_testing: AdversarialTestingConfigSchema.optional(),
+  integration_analysis: IntegrationAnalysisConfigSchema.optional(),
+  docs: DocsConfigSchema.optional(),
+  design_docs: DesignDocsConfigSchema.optional(),
+  ui_review: UIReviewConfigSchema.optional(),
+  compaction_advisory: CompactionAdvisoryConfigSchema.optional(),
+  lint: LintConfigSchema.optional(),
+  secretscan: SecretscanConfigSchema.optional(),
+  checkpoint: CheckpointConfigSchema.optional(),
+  automation: AutomationConfigSchema.optional(),
+  knowledge: KnowledgeConfigSchema.optional(),
+  memory: MemoryConfigSchema.optional(),
+  curator: CuratorConfigSchema.optional(),
+  architectural_supervision: ArchitecturalSupervisionConfigSchema.optional(),
+  knowledge_application: KnowledgeApplicationConfigSchema.optional(),
+  skillPropagation: SkillPropagationConfigSchema.optional(),
+  skill_improver: SkillImproverConfigSchema.optional(),
+  spec_writer: SpecWriterConfigSchema.optional(),
+  tool_output: exports_external.object({
+    truncation_enabled: exports_external.boolean().default(true),
+    max_lines: exports_external.number().min(10).max(500).default(150),
+    per_tool: exports_external.record(exports_external.string(), exports_external.number()).optional(),
+    truncation_tools: exports_external.array(exports_external.string()).optional().describe("Tools to apply output truncation to. Defaults to diff, symbols, bash, shell, test_runner, lint, pre_check_batch, complexity_hotspots, pkg_audit, sbom_generate, schema_drift.")
+  }).optional(),
+  slop_detector: SlopDetectorConfigSchema.optional(),
+  todo_gate: exports_external.object({
+    enabled: exports_external.boolean().default(true),
+    max_high_priority: exports_external.number().int().min(-1).default(0).describe("Max new high-priority TODOs (FIXME/HACK/XXX) before warning. 0 = warn on any. Set to -1 to disable."),
+    block_on_threshold: exports_external.boolean().default(false).describe("If true, block phase completion when threshold exceeded. Default: advisory only.")
+  }).optional(),
+  incremental_verify: IncrementalVerifyConfigSchema.optional(),
+  compaction_service: CompactionConfigSchema.optional(),
+  prm: PrmConfigSchema.optional(),
+  council: CouncilConfigSchema.optional(),
+  parallelization: ParallelizationConfigSchema.optional(),
+  worktree: WorktreeIsolationConfigSchema.optional(),
+  turbo: TurboConfigSchema.optional(),
+  turbo_mode: exports_external.boolean().default(false).optional(),
+  quiet: exports_external.boolean().default(true).optional(),
+  version_check: exports_external.boolean().default(true).optional(),
+  full_auto: exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    locked: exports_external.boolean().default(false),
+    critic_model: exports_external.string().optional(),
+    max_interactions_per_phase: exports_external.number().int().min(5).max(200).default(50),
+    deadlock_threshold: exports_external.number().int().min(2).max(10).default(3),
+    escalation_mode: exports_external.enum(["pause", "terminate"]).default("pause"),
+    mode: exports_external.enum(["assisted", "supervised", "strict"]).default("supervised"),
+    fail_closed: exports_external.boolean().default(true),
+    permission_policy: exports_external.object({
+      enabled: exports_external.boolean().default(true),
+      trusted_roots: exports_external.array(exports_external.string()).default(["."]),
+      trusted_domains: exports_external.array(exports_external.string()).default([]),
+      protected_paths: exports_external.array(exports_external.string()).default([
+        ".git",
+        ".github/workflows",
+        ".opencode",
+        ".swarm",
+        "package.json",
+        "package-lock.json",
+        "bun.lock",
+        "CHANGELOG.md",
+        ".release-please-manifest.json",
+        "release-please-config.json",
+        "src/index.ts",
+        "src/hooks/guardrails.ts",
+        "src/hooks/delegation-gate.ts",
+        "src/hooks/scope-guard.ts",
+        "src/hooks/full-auto-permission.ts",
+        "src/hooks/full-auto-intercept.ts",
+        "src/full-auto",
+        "src/config/schema.ts",
+        "src/config/constants.ts",
+        "src/tools/phase-complete.ts",
+        "dist"
+      ]),
+      allow_defaults: exports_external.boolean().default(true)
+    }).default(() => ({
+      enabled: true,
+      trusted_roots: ["."],
+      trusted_domains: [],
+      protected_paths: [
+        ".git",
+        ".github/workflows",
+        ".opencode",
+        ".swarm",
+        "package.json",
+        "package-lock.json",
+        "bun.lock",
+        "CHANGELOG.md",
+        ".release-please-manifest.json",
+        "release-please-config.json",
+        "src/index.ts",
+        "src/hooks/guardrails.ts",
+        "src/hooks/delegation-gate.ts",
+        "src/hooks/scope-guard.ts",
+        "src/hooks/full-auto-permission.ts",
+        "src/hooks/full-auto-intercept.ts",
+        "src/full-auto",
+        "src/config/schema.ts",
+        "src/config/constants.ts",
+        "src/tools/phase-complete.ts",
+        "dist"
+      ],
+      allow_defaults: true
+    })),
+    denials: exports_external.object({
+      max_consecutive: exports_external.number().int().min(1).max(50).default(3),
+      max_total: exports_external.number().int().min(1).max(500).default(20),
+      on_limit: exports_external.enum(["pause", "terminate"]).default("pause")
+    }).default(() => ({
+      max_consecutive: 3,
+      max_total: 20,
+      on_limit: "pause"
+    })),
+    oversight: exports_external.object({
+      on_plan_change: exports_external.boolean().default(true),
+      on_task_completion: exports_external.boolean().default(false),
+      on_phase_boundary: exports_external.boolean().default(true),
+      on_high_risk_action: exports_external.boolean().default(true),
+      on_subagent_return_warning: exports_external.boolean().default(true),
+      every_tool_calls: exports_external.number().int().min(0).max(1e4).default(25),
+      every_architect_turns: exports_external.number().int().min(0).max(1000).default(5),
+      every_minutes: exports_external.number().int().min(0).max(1440).default(20)
+    }).default(() => ({
+      on_plan_change: true,
+      on_task_completion: false,
+      on_phase_boundary: true,
+      on_high_risk_action: true,
+      on_subagent_return_warning: true,
+      every_tool_calls: 25,
+      every_architect_turns: 5,
+      every_minutes: 20
+    }))
+  }).optional().default(() => ({
+    enabled: false,
+    locked: false,
+    max_interactions_per_phase: 50,
+    deadlock_threshold: 3,
+    escalation_mode: "pause",
+    mode: "supervised",
+    fail_closed: true,
+    permission_policy: {
+      enabled: true,
+      trusted_roots: ["."],
+      trusted_domains: [],
+      protected_paths: [
+        ".git",
+        ".github/workflows",
+        ".opencode",
+        ".swarm",
+        "package.json",
+        "package-lock.json",
+        "bun.lock",
+        "CHANGELOG.md",
+        ".release-please-manifest.json",
+        "release-please-config.json",
+        "src/index.ts",
+        "src/hooks/guardrails.ts",
+        "src/hooks/delegation-gate.ts",
+        "src/hooks/scope-guard.ts",
+        "src/hooks/full-auto-permission.ts",
+        "src/hooks/full-auto-intercept.ts",
+        "src/full-auto",
+        "src/config/schema.ts",
+        "src/config/constants.ts",
+        "src/tools/phase-complete.ts",
+        "dist"
+      ],
+      allow_defaults: true
+    },
+    denials: {
+      max_consecutive: 3,
+      max_total: 20,
+      on_limit: "pause"
+    },
+    oversight: {
+      on_plan_change: true,
+      on_task_completion: false,
+      on_phase_boundary: true,
+      on_high_risk_action: true,
+      on_subagent_return_warning: true,
+      every_tool_calls: 25,
+      every_architect_turns: 5,
+      every_minutes: 20
+    }
+  })),
+  pr_monitor: PrMonitorConfigSchema.optional(),
+  external_skills: ExternalSkillsConfigSchema.optional()
+});
+
+export { ORCHESTRATOR_NAME, ALL_SUBAGENT_NAMES, ALL_AGENT_NAMES, TOOL_NAMES, TOOL_NAME_SET, AGENT_TOOL_MAP, DEFAULT_AGENT_CONFIGS, _internals, isKnownCanonicalRole, getCanonicalAgentRole, resolveGeneratedAgentRole, stripKnownSwarmPrefix, AgentReasoningConfigSchema, AgentThinkingConfigSchema, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AutoReviewConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, resolveGuardrailsConfig, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, KnowledgeConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, resolveExternalSkillsConfig, PluginConfigSchema };