@lucasreiners/lead 0.1.0

package/README.md

@@ -0,0 +1,337 @@
+# L.E.A.D. - Lucas Engineering Automation & Delivery
+
+Enterprise-grade [OpenCode](https://opencode.ai) plugin that turns a single AI agent into a **coordinated team of 9
+specialists** — from planning and research through implementation, testing, and review.
+
+## Quick Start
+
+1. **Add L.E.A.D.** to your OpenCode config (`~/.config/opencode/opencode.jsonc`):
+
+   ```jsonc
+   {
+     "plugin": ["@lucasreiners/lead@latest"]
+   }
+   ```
+
+2. **Restart OpenCode** — the plugin installs automatically from npm.
+
+## The Big Picture
+
+Instead of one AI agent, L.E.A.D. gives you a **team of 9 specialist agents** that work together — like a real
+engineering team. Each agent has its own role, permissions, and expertise.
+
+## How It Starts Up
+
+When OpenCode loads, it finds L.E.A.D. in the plugin config and runs the entry point:
+
+**`src/index.ts`** → This is "main()". It does 5 things in order:
+
+1. **Load config** → reads `.opencode/lead.jsonc` (project) and `~/.config/opencode/lead.jsonc` (global) to get your
+   customizations
+2. **Load skills** → finds any skill files (reusable prompt snippets) from disk
+3. **Create agents** → builds all 9 builtin agents + any custom ones you defined
+4. **Create hooks** → sets up ~15 lifecycle hooks that monitor and enhance agent behavior
+5. **Return the plugin interface** → hands everything to OpenCode as a set of hooks
+
+## The Agent Team
+
+Each agent is defined in `src/agents/<name>/index.ts` with an accompanying `prompt.md`:
+
+| Agent              | Role                                               | Can Write Code? | When It's Used                               |
+|--------------------|----------------------------------------------------|-----------------|----------------------------------------------|
+| **Tech Lead**      | Orchestrator — routes work to the right specialist | ❌ No            | Default agent, handles all incoming requests |
+| **Engineer**       | Writes code, fixes bugs, implements features       | ✅ Yes           | Direct implementation tasks                  |
+| **Lead Developer** | Executes plans step-by-step                        | ✅ Yes           | Activated by `/implement` command            |
+| **Architect**      | Creates implementation plans (`.md` files only)    | 📝 Only `.md`   | Complex features needing planning first      |
+| **Code Analyst**   | Explores codebases, traces dependencies            | ❌ Read-only     | Understanding existing code                  |
+| **Researcher**     | Looks up external docs, libraries, APIs            | ❌ Read-only     | "How does library X work?"                   |
+| **Reviewer**       | Code review, gives APPROVE/REJECT verdict          | ❌ Read-only     | Quality validation                           |
+| **Tester**         | Runs tests, linters, type checks — reports PASS/FAIL | ❌ Read + bash  | Verification after each implementation task  |
+| **Guardian**       | Security audit, OWASP checks                       | ❌ Read-only     | Security-sensitive changes                   |
+
+### How Agents Are Built
+
+- Each agent starts as a **factory function** (`src/agents/agent-builder.ts`) that takes a model name and returns a
+  config
+- The factory has a `mode` property (`"primary"`, `"subagent"`, or `"all"`) that controls visibility in the UI
+- `createBuiltinAgents()` in `src/agents/builtin-agents.ts` calls each factory, resolves the model, and applies any
+  config overrides
+
+### How Agents Get Registered
+
+- The `ConfigHandler` (`src/managers/config-handler.ts`) takes all built agents and writes them into OpenCode's config
+  object
+- Agent keys use display names ("Tech Lead" not "tech-lead") for cleaner UI
+- Sets `config.default_agent = "Tech Lead"` so it appears first
+
+### Architecture
+
+```
+                    User
+                      |
+                  Tech Lead          (orchestrator, read-only)
+                 /    |    \
+          Architect  Code Analyst  Researcher   (planning / exploration / research)
+                |
+             Lead Dev               (plan execution, full permissions)
+               / \
+        Engineer   Tester           (implement → verify cycle)
+                |
+          Reviewer + Guardian       (validation, read-only)
+```
+
+### Tool Permissions
+
+| Agent      | bash | edit | write    | read/glob/grep | web |
+|------------|------|------|----------|----------------|-----|
+| Tech Lead  | -    | -    | -        | yes            | yes |
+| Lead Dev   | yes  | yes  | yes      | yes            | yes |
+| Engineer   | yes  | yes  | yes      | yes            | yes |
+| Architect  | -    | -    | .md only | yes            | yes |
+| Code Analyst | -    | -    | -        | yes            | -   |
+| Researcher | -    | -    | -        | yes            | yes |
+| Reviewer   | -    | -    | -        | yes            | -   |
+| Tester     | yes  | -    | -        | yes            | -   |
+| Guardian   | -    | -    | -        | yes            | -   |
+
+## The Hooks System
+
+Hooks are the plugin's nervous system — they intercept events at every stage of OpenCode's lifecycle. They're created in
+`src/hooks/create-hooks.ts` and wired up in `src/runtime/opencode/plugin-adapter.ts`.
+
+### Plugin Adapter Hooks
+
+| Hook                              | What Triggers It          | What L.E.A.D. Does                                            |
+|-----------------------------------|---------------------------|---------------------------------------------------------------|
+| `config`                          | Plugin loads              | Registers all agents                                          |
+| `chat.message`                    | Every message sent        | Tracks active agent, injects any pending continuation prompts |
+| `event` (session.idle)            | Agent finishes responding | Checks if there's more plan work to do → auto-continues       |
+| `command.execute.before`          | User runs a `/command`    | Handles `/implement` and `/run-workflow`                      |
+| `tool.execute.before`             | Agent calls a tool        | Guards architect (only `.md`), captures todo writes           |
+| `tool.execute.after`              | Tool finishes             | Reminds agent to verify (typecheck, test)                     |
+| `tool.definition`                 | Tool list requested       | Overrides todowrite description                               |
+| `experimental.session.compacting` | Context window compressed | Preserves work state & todos through compaction               |
+
+### Individual Hook Files (`src/hooks/`)
+
+| Hook                           | File                            | Purpose                                                               |
+|--------------------------------|---------------------------------|-----------------------------------------------------------------------|
+| **start-implementation**       | `start-implementation-hook.ts`  | `/implement` command — find plan, create work state                   |
+| **work-continuation**          | `work-continuation.ts`          | On idle, check active work, detect stale continuations, return prompt |
+| **architect-md-only**          | `architect-md-only.ts`          | Guard: architect only writes `.md` in `.lead/`                        |
+| **todo-writer**                | `todo-writer.ts`                | Capture todowrite operations for state tracking                       |
+| **verification-reminder**      | `verification-reminder.ts`      | After edit/write/bash, remind agent to typecheck and test             |
+| **compaction-recovery**        | `compaction-recovery.ts`        | After context compaction, re-inject active work summary               |
+| **compaction-todo-preserver**  | `compaction-todo-preserver.ts`  | Save/restore todo state through compaction                            |
+| **context-window-monitor**     | `context-window-monitor.ts`     | Warn at 75% and 90% context window usage                              |
+| **write-existing-file-guard**  | `write-existing-file-guard.ts`  | Prevent overwriting files the agent hasn't read first                 |
+| **keyword-detector**           | `keyword-detector.ts`           | Detect `/implement`, `/run-workflow`, workflow control keywords       |
+| **rules-injector**             | `rules-injector.ts`             | Inject project rules from `.opencode/rules/*.md`                      |
+| **first-message-variant**      | `first-message-variant.ts`      | Track sessions for first-message-only prompt injection                |
+| **todo-continuation-enforcer** | `todo-continuation-enforcer.ts` | Detect stale in-progress todos, prompt to complete/cancel             |
+| **todo-description-override**  | `todo-description-override.ts`  | Override todowrite description with executor discipline rules         |
+| **session-token-state**        | `session-token-state.ts`        | Track input/output tokens per session                                 |
+
+## The `/implement` Command Flow
+
+This is the core workflow for executing plans:
+
+```
+1. User: /implement PROJ-123  (or /implement my-feature)
+     ↓
+2. start-implementation-hook.ts
+   - Searches .lead/PROJ-123/plan.md, .lead/_adhoc/my-feature.md, .lead/plans/ (legacy)
+   - Creates work state in .lead/state.json
+   - Returns prompt: "You are now the Executor..."
+     ↓
+3. Lead Developer agent starts working
+   - Reads the plan file
+   - Finds first unchecked - [ ] task
+   - Implements it (code, tests, etc.)
+     ↓
+4. Lead Dev delegates to Tester agent
+   - Tester reads AGENTS.md for project-specific commands
+   - Runs typecheck → lint → tests
+   - Returns [PASS] or [FAIL]
+     ↓
+5. If [FAIL]: Lead Dev fixes issues → back to step 4 (max 3 cycles)
+   If [PASS]: marks task - [x], moves to next task
+     ↓
+6. Session goes idle → work-continuation.ts
+   - Checks: are there remaining tasks?
+   - Yes → injects "Continue working on plan..."
+   - Agent resumes automatically
+     ↓
+7. All tasks checked → work complete
+```
+
+### State Files
+
+- `.lead/state.json` — tracks active plan, session, pause status
+- `.lead/<ticket>/plan.md` — ticket-linked plans (e.g. `.lead/PROJ-123/plan.md`)
+- `.lead/_adhoc/*.md` — ad-hoc plans with no ticket reference
+
+## The Workflow Engine
+
+Beyond `/implement`, there's a full workflow system in `src/features/workflow/`:
+
+- Workflow definitions live in `.opencode/workflows/*.jsonc`
+- Each workflow has ordered **steps** with specific agents, prompts, and completion criteria
+- The engine (`engine.ts`) is a state machine that advances through steps
+- Steps can complete via: user confirmation, plan created, review verdict, etc.
+
+### Workflow Flow
+
+```
+1. User: /run-workflow my-workflow "build new feature"
+     ↓
+2. handleRunWorkflow()
+   - Discovers workflows in .opencode/workflows/*.jsonc
+   - Validates schema, starts first step
+   - Saves state to .lead/workflow/{id}.json
+     ↓
+3. Step agent executes (e.g., Architect creates plan)
+     ↓
+4. On session.idle → checkWorkflowContinuation()
+   - Checks step completion (user_confirm, plan_created, etc.)
+   - Marks step complete, advances to next
+   - Switches agent, injects next step prompt
+     ↓
+5. Last step completes → workflow done
+```
+
+## Configuration
+
+**`src/config/`** handles loading and merging config:
+
+- `schema.ts` — Zod schemas define what's valid
+- `loader.ts` — Loads global + project configs
+- `merge.ts` — Deep merges them (project wins)
+
+L.E.A.D. loads config from `.opencode/lead.jsonc` (project-level) and `~/.config/opencode/lead.jsonc` (global). Project
+config takes precedence.
+
+```jsonc
+{
+  // Override model for all agents
+  "model": "anthropic/claude-sonnet-4-5",
+
+  // Disable specific builtin agents
+  "disabled_agents": ["guardian"],
+
+  // Disable specific hooks
+  "disabled_hooks": ["verification-reminder"],
+
+  // Add custom agents
+  "custom_agents": {
+    "my-agent": {
+      "model": "anthropic/claude-sonnet-4-5",
+      "prompt": "You are a specialized agent for...",
+      "mode": "subagent"
+    }
+  }
+}
+```
+
+## Build Process
+
+`script/build.ts` uses Bun's bundler:
+
+- Entry: `src/index.ts` → Output: `dist/index.js` (ESM)
+- Externals: `@opencode-ai/plugin`, `@opencode-ai/sdk`, `zod`, `picocolors`
+- OpenCode loads `dist/index.js` at startup
+
+## Key Project Directories
+
+```
+your-project/
+├── .opencode/
+│   ├── lead.jsonc      ← project config
+│   ├── rules/*.md         ← project rules injected into prompts
+│   └── workflows/*.jsonc  ← workflow definitions
+├── .lead/
+│   ├── state.json         ← active work tracking
+│   ├── PROJ-123/plan.md   ← ticket-linked plans
+│   ├── _adhoc/*.md        ← ad-hoc plans (no ticket)
+│   └── workflow/           ← workflow state
+```
+
+## Source File Organization
+
+```
+src/
+├── index.ts                          ← MAIN ENTRY POINT
+├── create-tools.ts                   ← skill loading orchestration
+├── create-managers.ts                ← agent & manager factory
+│
+├── config/                           ← configuration layer
+│   ├── schema.ts                       (zod validation)
+│   ├── loader.ts                       (load from disk)
+│   ├── merge.ts                        (deep merge logic)
+│   └── continuation.ts                 (continuation defaults)
+│
+├── plugin/                           ← plugin interface wrapper
+│   ├── plugin-interface.ts             (adapter → Hooks)
+│   └── types.ts                        (PluginContext, LeadHooks)
+│
+├── runtime/opencode/
+│   └── plugin-adapter.ts            ← ALL HOOK IMPLEMENTATIONS
+│
+├── agents/                           ← the agent team
+│   ├── types.ts                        (AgentFactory, AgentMode)
+│   ├── builtin-agents.ts              (factory registry + metadata)
+│   ├── agent-builder.ts               (factory → AgentConfig)
+│   ├── custom-agent-factory.ts        (custom agent builder)
+│   ├── model-resolution.ts            (model selection logic)
+│   ├── dynamic-prompt-builder.ts      (Tech Lead delegation table)
+│   ├── prompt-loader.ts               (read prompt.md files)
+│   ├── prompt-utils.ts                (normalize prompts)
+│   ├── tech-lead/                     (orchestrator)
+│   ├── lead-dev/                      (plan executor)
+│   ├── engineer/                      (implementer)
+│   ├── architect/                     (planner)
+│   ├── code-analyst/                  (explorer)
+│   ├── researcher/                    (external research)
+│   ├── reviewer/                      (quality review)
+│   ├── tester/                        (verification — runs tests/lint)
+│   └── guardian/                      (security audit)
+│
+├── managers/                         ← system managers
+│   ├── config-handler.ts               (register agents into OpenCode)
+│   ├── background-manager.ts           (concurrent task tracking)
+│   └── skill-mcp-manager.ts            (MCP server stub)
+│
+├── features/                         ← feature modules
+│   ├── skill-loader/                   (API + FS skill discovery)
+│   ├── work-state/                     (plan execution tracking)
+│   └── workflow/                       (workflow state machine)
+│
+├── hooks/                            ← ~15 lifecycle hooks
+│   ├── create-hooks.ts                 (hook factory)
+│   ├── start-implementation-hook.ts    (/implement command)
+│   ├── work-continuation.ts            (auto-continue work)
+│   ├── architect-md-only.ts            (write guard)
+│   ├── verification-reminder.ts        (test/typecheck reminders)
+│   ├── compaction-recovery.ts          (context preservation)
+│   ├── context-window-monitor.ts       (usage warnings)
+│   ├── write-existing-file-guard.ts    (read-before-write)
+│   ├── keyword-detector.ts             (command detection)
+│   ├── rules-injector.ts               (project rules)
+│   └── ...                             (+ 5 more hooks)
+│
+├── shared/                           ← utilities
+│   ├── log.ts                          (structured logging)
+│   ├── agent-display-names.ts          (ID → display name)
+│   ├── resolve-safe-path.ts            (path traversal protection)
+│   └── version.ts                      (version constant)
+│
+├── domain/                           ← domain types (stubs)
+│   └── policy/policy-result.ts         (allow/deny verdicts)
+│
+└── infrastructure/fs/
+    └── config-fs-loader.ts             (JSONC file loading)
+```
+
+## License
+
+MIT

package/dist/agents/agent-builder.d.ts

@@ -0,0 +1,30 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentSource } from "./types";
+import type { CategoriesConfig } from "../config/schema";
+export type ResolveSkillsFn = (skillNames: string[], disabledSkills?: Set<string>) => string;
+export interface BuildAgentOptions {
+    categories?: CategoriesConfig;
+    disabledSkills?: Set<string>;
+    resolveSkills?: ResolveSkillsFn;
+    disabledAgents?: Set<string>;
+}
+export declare function registerAgentNameVariants(name: string, variants: string[]): void;
+export declare function addBuiltinNameVariant(name: string, variant: string): void;
+export declare function resetNameVariants(): void;
+/**
+ * Removes lines from a prompt that mention disabled agent names.
+ * A "line" is considered to mention an agent if it contains any of that
+ * agent's known variant strings.
+ */
+export declare function stripDisabledAgentReferences(prompt: string, disabledAgents: Set<string>): string;
+/**
+ * Resolves an `AgentSource` (factory or static config) into a fully
+ * populated `AgentConfig`.
+ *
+ * Steps:
+ * 1. Resolve factory → config
+ * 2. Apply category overrides
+ * 3. Prepend skill content to prompt
+ * 4. Strip references to disabled agents
+ */
+export declare function buildAgent(source: AgentSource, model: string, options?: BuildAgentOptions): AgentConfig;

package/dist/agents/architect/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const ARCHITECT_DEFAULTS: AgentConfig;
+export declare const createArchitectAgent: AgentFactory;

package/dist/agents/builtin-agents.d.ts

@@ -0,0 +1,32 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { LeadAgentName, AgentFactory } from "./types";
+import type { BuildAgentOptions } from "./agent-builder";
+import type { AgentOverrideConfig } from "../config/schema";
+export interface AgentMetadata {
+    category: string;
+    cost: "CHEAP" | "MODERATE" | "EXPENSIVE";
+    triggers: Array<{
+        domain: string;
+        trigger: string;
+    }>;
+    useWhen?: string;
+    avoidWhen?: string;
+}
+export interface CreateBuiltinAgentsOptions {
+    uiModel?: string;
+    disabledAgents?: Set<string>;
+    configOverrides?: Record<string, AgentOverrideConfig>;
+    buildOptions?: Omit<BuildAgentOptions, "disabledAgents">;
+}
+export declare const AGENT_FACTORIES: Record<LeadAgentName, AgentFactory>;
+export declare const AGENT_METADATA: Record<LeadAgentName, AgentMetadata>;
+export declare function registerCustomAgentMetadata(name: string, metadata: AgentMetadata): void;
+export declare function getAllAgentMetadata(): Record<string, AgentMetadata>;
+/**
+ * Builds all 8 builtin agents, respecting disabled list, model overrides,
+ * config overrides, and skill resolution options.
+ *
+ * Returns a record mapping agent names to their resolved `AgentConfig`.
+ * Disabled agents are excluded from the result.
+ */
+export declare function createBuiltinAgents(options?: CreateBuiltinAgentsOptions): Partial<Record<LeadAgentName, AgentConfig>>;

package/dist/agents/code-analyst/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const CODE_ANALYST_DEFAULTS: AgentConfig;
+export declare const createCodeAnalystAgent: AgentFactory;

package/dist/agents/cto/index.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+import { type AvailableAgent } from "../dynamic-prompt-builder";
+export declare const LEAD_DEFAULTS: AgentConfig;
+export interface CreateLeadAgentOptions {
+    disabledAgents?: Set<string>;
+    fingerprint?: string;
+    customAgents?: AvailableAgent[];
+}
+export declare function createLeadAgentWithOptions(model: string, options?: CreateLeadAgentOptions): AgentConfig;
+export declare const createLeadAgent: AgentFactory;

package/dist/agents/custom-agent-factory.d.ts

@@ -0,0 +1,27 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { CustomAgentConfig } from "../config/schema";
+import type { AgentMetadata } from "./builtin-agents";
+import type { BuildAgentOptions } from "./agent-builder";
+export interface BuildCustomAgentOptions extends BuildAgentOptions {
+    directory?: string;
+}
+/**
+ * Builds an `AgentConfig` from a custom agent definition loaded from config.
+ *
+ * Supports:
+ * - Inline `prompt` string
+ * - `prompt_file` path (relative to directory, sandboxed via resolveSafePath)
+ * - `model`, `tools`, `skills`, `mode`, `description`
+ */
+export declare function buildCustomAgent(name: string, config: CustomAgentConfig, options?: BuildCustomAgentOptions): AgentConfig;
+/**
+ * Derives `AgentMetadata` from a `CustomAgentConfig`.
+ */
+export declare function buildCustomAgentMetadata(name: string, config: CustomAgentConfig): AgentMetadata;
+declare module "./agent-builder" {
+    interface BuildAgentOptions {
+        buildOptions?: {
+            model?: string;
+        };
+    }
+}

package/dist/agents/dynamic-prompt-builder.d.ts

@@ -0,0 +1,22 @@
+import type { LeadAgentName } from "./types";
+export interface AvailableAgent {
+    name: string;
+    displayName: string;
+    description: string;
+    useWhen?: string;
+    avoidWhen?: string;
+    isCustom?: boolean;
+}
+export interface BuildDynamicLeadPromptOptions {
+    enabledAgents: AvailableAgent[];
+    fingerprint?: string;
+    customAgentCount?: number;
+}
+/**
+ * Builds the dynamic section of the CTO agent's system prompt.
+ *
+ * This is appended to the static prompt.md at runtime so it always reflects
+ * the current set of enabled agents and any custom agents loaded from config.
+ */
+export declare function buildDynamicLeadPrompt(options: BuildDynamicLeadPromptOptions): string;
+export declare const BUILTIN_AGENT_DISPLAY: Record<LeadAgentName, AvailableAgent>;

package/dist/agents/engineer/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const ENGINEER_DEFAULTS: AgentConfig;
+export declare const createEngineerAgent: AgentFactory;

package/dist/agents/executor/index.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+import type { ContinuationConfig } from "../../config/schema";
+export declare const EXECUTOR_DEFAULTS: AgentConfig;
+export declare function createExecutorAgentWithOptions(model: string, _disabledAgents?: Set<string>, _continuation?: ContinuationConfig): AgentConfig;
+export declare const createExecutorAgent: AgentFactory;

package/dist/agents/guardian/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const GUARDIAN_DEFAULTS: AgentConfig;
+export declare const createGuardianAgent: AgentFactory;

package/dist/agents/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./types";
+export * from "./agent-builder";
+export * from "./builtin-agents";
+export * from "./custom-agent-factory";
+export * from "./model-resolution";
+export * from "./dynamic-prompt-builder";
+export * from "./prompt-utils";
+export * from "./prompt-loader";
+export { createLeadAgent, createLeadAgentWithOptions, LEAD_DEFAULTS } from "./tech-lead/index";
+export { createExecutorAgent, createExecutorAgentWithOptions, EXECUTOR_DEFAULTS } from "./lead-dev/index";
+export { createEngineerAgent, ENGINEER_DEFAULTS } from "./engineer/index";
+export { createArchitectAgent, ARCHITECT_DEFAULTS } from "./architect/index";
+export { createCodeAnalystAgent, CODE_ANALYST_DEFAULTS } from "./code-analyst/index";
+export { createResearcherAgent, RESEARCHER_DEFAULTS } from "./researcher/index";
+export { createReviewerAgent, REVIEWER_DEFAULTS } from "./reviewer/index";
+export { createTesterAgent, TESTER_DEFAULTS } from "./tester/index";
+export { createGuardianAgent, GUARDIAN_DEFAULTS } from "./guardian/index";

package/dist/agents/lead/index.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+import { type AvailableAgent } from "../dynamic-prompt-builder";
+export declare const LEAD_DEFAULTS: AgentConfig;
+export interface CreateLeadAgentOptions {
+    disabledAgents?: Set<string>;
+    fingerprint?: string;
+    customAgents?: AvailableAgent[];
+}
+export declare function createLeadAgentWithOptions(model: string, options?: CreateLeadAgentOptions): AgentConfig;
+export declare const createLeadAgent: AgentFactory;

package/dist/agents/lead-dev/index.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+import type { ContinuationConfig } from "../../config/schema";
+export declare const EXECUTOR_DEFAULTS: AgentConfig;
+export declare function createExecutorAgentWithOptions(model: string, _disabledAgents?: Set<string>, _continuation?: ContinuationConfig): AgentConfig;
+export declare const createExecutorAgent: AgentFactory;

package/dist/agents/model-resolution.d.ts

@@ -0,0 +1,44 @@
+import type { LeadAgentName } from "./types";
+/**
+ * Engineering tier — implementation & analysis agents.
+ * Gets a fast, capable model optimized for code tasks.
+ */
+/** Strategic tier: prefer Opus 4.6, fall back through capable models */
+export declare const STRATEGIC_MODEL_CHAIN: readonly string[];
+/** Engineering tier: prefer Sonnet 4.6, fall back through fast models */
+export declare const ENGINEERING_MODEL_CHAIN: readonly string[];
+export interface ResolveAgentModelOptions {
+    /** The model selected by the user in the UI (only relevant for primary agents) */
+    uiModel?: string;
+    /** Per-agent model override from config */
+    configOverride?: string;
+    /** Global fallback model from config */
+    globalFallback?: string;
+}
+/**
+ * Returns the default model chain for an agent based on its tier.
+ */
+export declare function getModelChain(agentName: LeadAgentName | string): readonly string[];
+/**
+ * Returns the default (first) model for an agent based on its tier.
+ */
+export declare function getDefaultModel(agentName: LeadAgentName | string): string;
+/**
+ * Determines which model to use for a given agent.
+ *
+ * Resolution order:
+ * 1. Per-agent config override (highest priority)
+ * 2. For primary agents: UI-selected model
+ * 3. Global fallback from config
+ * 4. Tier default (strategic → Opus, engineering → Sonnet)
+ */
+export declare function resolveAgentModel(agentName: LeadAgentName | string, options?: ResolveAgentModelOptions): string;
+/**
+ * Returns true if the agent is a primary agent (tech-lead, lead-dev).
+ * Primary agents appear in the UI model selector.
+ */
+export declare function isPrimaryAgent(agentName: LeadAgentName | string): boolean;
+/**
+ * Returns true if the agent is in the strategic tier (uses Opus-class models).
+ */
+export declare function isStrategicAgent(agentName: LeadAgentName | string): boolean;

package/dist/agents/prompt-loader.d.ts

@@ -0,0 +1,30 @@
+import type { LeadAgentName } from "./types";
+/**
+ * Prompt loader for agent definitions.
+ *
+ * At runtime, agent prompt strings are embedded directly in their respective
+ * `index.ts` factory files (via the prompt.md files read at build time or
+ * inlined as template literals). This module provides a thin utility that
+ * loads an agent's default prompt from its `prompt.md` file.
+ *
+ * If the file cannot be read (e.g. in a bundled/dist context where the file
+ * isn't present), it returns `null` and the caller falls back to the inline
+ * default prompt string.
+ */
+export interface PromptLoadResult {
+    prompt: string;
+    source: "file" | "inline";
+}
+/**
+ * Attempts to load a prompt string from the agent's prompt.md file.
+ * Returns null if the file does not exist or cannot be read.
+ */
+export declare function tryLoadPromptFile(agentName: LeadAgentName | string): string | null;
+/**
+ * Synchronously reads the prompt.md embedded during module evaluation.
+ * Agent factories call this at module load time to read their adjacent prompt.md.
+ *
+ * Usage in an agent index.ts:
+ *   const PROMPT = readPromptMd(import.meta.url) ?? INLINE_FALLBACK
+ */
+export declare function readPromptMd(importMetaUrl: string): string | null;

package/dist/agents/prompt-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Trims leading/trailing whitespace from each line and collapses consecutive
+ * blank lines into at most one blank line. Also trims the entire result.
+ *
+ * Used by agent prompt builders to normalize inline prompt strings.
+ */
+export declare function trimPrompt(text: string): string;
+/**
+ * Strips leading/trailing blank lines from each section of an XML-style tag.
+ * Useful for cleaning up agent prompt templates before injection.
+ */
+export declare function normalizeXmlSection(tag: string, content: string): string;

package/dist/agents/researcher/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const RESEARCHER_DEFAULTS: AgentConfig;
+export declare const createResearcherAgent: AgentFactory;

package/dist/agents/reviewer/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const REVIEWER_DEFAULTS: AgentConfig;
+export declare const createReviewerAgent: AgentFactory;

package/dist/agents/scout/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const SCOUT_DEFAULTS: AgentConfig;
+export declare const createScoutAgent: AgentFactory;

package/dist/agents/tech-lead/index.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+import { type AvailableAgent } from "../dynamic-prompt-builder";
+export declare const LEAD_DEFAULTS: AgentConfig;
+export interface CreateLeadAgentOptions {
+    disabledAgents?: Set<string>;
+    fingerprint?: string;
+    customAgents?: AvailableAgent[];
+}
+export declare function createLeadAgentWithOptions(model: string, options?: CreateLeadAgentOptions): AgentConfig;
+export declare const createLeadAgent: AgentFactory;