opencode-titan 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zack Duford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,257 @@
+<div align="center">
+  <h3>⚡ opencode-titan ⚡</h3>
+
+  <p><i>One mind that never touches the keyboard. A fleet of hands that never stops moving.<br>Plan with the slow, expensive genius, and let the fast ones build in parallel.</i></p>
+
+  <p><b>OpenCode Orchestration Plugin</b> · Mix any models · Delegate everything · Run in parallel</p>
+
+  <p><sub>✦ ✦ ✦</sub></p>
+
+</div>
+
+## What's This Plugin
+
+`opencode-titan` is an agent-orchestration plugin for [OpenCode](https://github.com/sst/opencode). It introduces a **Titan orchestrator** — your most capable (and slowest, most expensive) model — whose only job is to think, plan, and route. Every piece of executable work is handed off to a fleet of faster **Myrmidons** that run in parallel.
+
+The core idea is simple: **your smartest model is often your slowest and most expensive one.** Titan is meant to be a frontier heavyweight — something like Opus 5.5, GLM 5.2, or a beast like Nex N2 Pro running on local hardware: far slower and pricier than a typical local model, but far smarter. Instead of letting a model like that grind through file reads, searches, and edits — burning tokens and wall-clock time on grunt work — Titan spends its expensive inference budget only on planning and synthesis, while cheaper, faster Myrmidons do the legwork simultaneously.
+
+The result is a workflow that balances **quality, speed, and cost** — deep reasoning where it matters, raw throughput everywhere else.
+
+To meet the agents, jump to **[Meet the Agents](#meet-the-agents)**. For setup, see **[Getting Started](#getting-started)**.
+
+## How It Works
+
+The plugin builds a two-tier hierarchy of agents:
+
+- **Titan** dispatches all independent tasks to Myrmidons **in parallel** within a single response turn.
+- **Myrmidons** share model providers, so Myrmidons running **different models** on the same provider are scheduled sequentially — a provider (physical backend) holds only one model in VRAM at a time. A Myrmidon with `maxInstances > 1` is the exception: multiple instances of its *same* model run in parallel on that provider. The plugin detects provider conflicts and warns Titan so it can plan around them.
+- Titan **never** performs work a Myrmidon can handle — it plans, routes, quality-gates, and synthesizes results.
+
+> [!TIP]
+> The magic is in the prompt. Titan's system prompt is generated dynamically per session from your configured fleet — it knows each Myrmidon's speed, intelligence, model type, and provider, and delegates accordingly.
+
+## Installation
+
+> [!NOTE]
+> This plugin is not published to npm yet, so install it manually from source. npm/Bun package installation is coming soon.
+
+**1. Clone and build the plugin:**
+
+```bash
+git clone https://github.com/DEV-DUFORD/opencode-titan.git
+cd opencode-titan
+bun install
+bun run build
+```
+
+This produces the bundled plugin in `dist/`.
+
+**2. Register the local build in your OpenCode config** (`opencode.json`).
+
+OpenCode treats any plugin entry starting with `.`, `file://`, or an absolute path as a local file plugin, so point it at the cloned directory:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["/absolute/path/to/opencode-titan"]
+}
+```
+
+Restart OpenCode and Titan becomes your default agent.
+
+## Getting Started
+
+1. **Create your plugin config** at `~/.config/opencode/opencode-titan.jsonc`
+
+2. **Pick your Titan** — the smartest model you have, even if it's slow and expensive (think Opus 5.5, GLM 5.2, or Nex N2 Pro on local hardware).
+
+3. **Assemble your fleet** — one or more Myrmidons, each rated for `speed`, `intelligence`, and `modelType`.
+
+4. **Start OpenCode.** Titan becomes the default agent and delegates from there.
+
+Here's a complete starting configuration:
+
+```jsonc
+{
+  // Optional: override Titan's model and settings.
+  // Titan should be your most capable model, even if it's slow and expensive.
+  "titan": {
+    "model": "anthropic/claude-sonnet-4-20250514",
+    "temperature": 0.1
+  },
+
+  // Required: at least one Myrmidon.
+  // Myrmidons should be fast and cheap — they do the actual work.
+  "myrmidons": [
+    {
+      "model": "openai/gpt-4.1-mini",
+      "speed": 9,
+      "intelligence": 6,
+      "modelType": "sparse",
+      "displayName": "Fast Searcher"
+    },
+    {
+      "model": "anthropic/claude-haiku-3.5",
+      "speed": 7,
+      "intelligence": 8,
+      "modelType": "dense"
+    }
+  ]
+}
+```
+
+> [!NOTE]
+> The legacy `children` key is still accepted as a deprecated alias for `myrmidons` (and each Myrmidon is also routable under its old `child-N` name), so existing configs keep working. New configs should use `myrmidons`. If both keys are present, `myrmidons` wins.
+
+> [!TIP]
+> Mix providers to unlock real parallelism. Two Myrmidons running **different models** on the same provider run one after another; two Myrmidons on *different* providers run at the same time. Set `maxInstances` on a Myrmidon to run several copies of its *same* model in parallel on one provider.
+
+## Meet the Agents
+
+### 🧠 Titan — The Orchestrator
+
+Titan is the most intelligent agent in the fleet, and by far the slowest and most expensive to run. It never reads a file, runs a search, or writes a line of code if a Myrmidon can do it instead. Its entire purpose is strategic: decompose the goal, route each task to the best-suited Myrmidon, gate the quality of what comes back, and synthesize the final result.
+
+<table>
+  <tr><td><b>Role</b></td><td><code>Planning, routing, quality-gating, and synthesis</code></td></tr>
+  <tr><td><b>Prompt</b></td><td><a href="src/agents/titan.ts"><code>titan.ts</code></a> — dynamically built from your fleet</td></tr>
+  <tr><td><b>Model Guidance</b></td><td>Choose your strongest reasoning model — an expensive frontier model (Opus 5.5, GLM 5.2) or a heavy local model like Nex N2 Pro. Titan needs judgment and instruction-following, not throughput. Slow and expensive is fine — it delegates the slow, token-hungry parts away.</td></tr>
+</table>
+
+### ⚙️ Myrmidons — The Fleet
+
+Myrmidons are the hands. Each executes a delegated task and reports back concisely — responses to Titan are enforced to a single paragraph, 500 words max, keeping Titan's context lean. Every Myrmidon declares a `modelType` that shapes how Titan routes work to it:
+
+<table>
+  <tr>
+    <td width="20%" valign="top"><b>🔍 sparse</b></td>
+    <td valign="top">Faster models tuned for <b>information gathering</b> — searching the codebase, reading files, collecting context. Route broad reconnaissance here.</td>
+  </tr>
+  <tr>
+    <td width="20%" valign="top"><b>🛠️ dense</b></td>
+    <td valign="top">Models tuned for <b>logic and reasoning</b> — implementation, refactors, and tasks that need careful thought. Route the hard thinking here.</td>
+  </tr>
+</table>
+
+<table>
+  <tr><td><b>Role</b></td><td><code>Execute delegated tasks and report back concisely</code></td></tr>
+  <tr><td><b>Prompt</b></td><td><a href="src/agents/myrmidon.ts"><code>myrmidon.ts</code></a></td></tr>
+  <tr><td><b>Model Guidance</b></td><td>Choose fast, cost-efficient models. Speed and parallelism usually matter more than raw reasoning power here.</td></tr>
+</table>
+
+## Configuration
+
+### Myrmidon Options
+
+| Field | Type | Required | Description |
+|---|---|:---:|---|
+| `model` | `string` | ✅ | Model identifier in `provider/model` format |
+| `speed` | `number` (1–10) | ✅ | Relative speed rating; higher = faster responses |
+| `intelligence` | `number` (1–10) | ✅ | Reasoning capability rating; higher = better logic |
+| `modelType` | `"dense"` \| `"sparse"` | ✅ | `dense` for logic/reasoning, `sparse` for search/info gathering |
+| `maxInstances` | `number` (≥1) | | Max parallel instances Titan may run for this Myrmidon. Since instances share the same model (already in the provider's VRAM), they run concurrently on the same provider. Default: `1` |
+| `temperature` | `number` (0–2) | | Sampling temperature (default: `0.1`) |
+| `variant` | `string` | | Selects a named model variant defined by the provider for this `model` (see [Model variants](#model-variants)). Must match a variant key the provider declares for the model; leave unset to use the model's defaults |
+| `displayName` | `string` | | Friendly name shown in the UI |
+| `provider` | `string` | | Explicit provider name (defaults to the prefix of `model`) |
+
+### Titan Options
+
+| Field | Type | Description |
+|---|---|---|
+| `model` | `string` | Titan's model in `provider/model` format |
+| `temperature` | `number` (0–2) | Sampling temperature (default: `0.1`) |
+| `variant` | `string` | Selects a named model variant defined by the provider for Titan's `model` (see [Model variants](#model-variants)). Must match a variant key the provider declares for the model; leave unset to use the model's defaults |
+| `prompt` | `string` | Inline custom system prompt (replaces the default entirely) |
+
+### Plugin Options
+
+| Field | Type | Description |
+|---|---|---|
+| `titan` | `object` | Titan overrides (see above) |
+| `myrmidons` | `array` | The Myrmidon fleet (see above) |
+| `children` | `array` | **Deprecated** alias for `myrmidons`, kept for backwards compatibility. Prefer `myrmidons`; if both are set, `myrmidons` wins |
+| `disabled_tools` | `string[]` | Tool names to disable for the plugin's agents |
+| `backgroundJobs.maxSessionsPerAgent` | `number` (1–10) | Max concurrent sessions per agent (default: `10`) |
+
+### Config Locations
+
+Config is loaded in two layers — **project settings override user settings** via deep merge:
+
+1. **User-level** — searched in `$XDG_CONFIG_HOME/opencode/`, `~/.config/opencode/`, then `~/.opencode/`
+2. **Project-level** — `.opencode/opencode-titan.{json,jsonc}`
+
+Both `.json` and `.jsonc` are supported. JSONC files allow comments (`//`, `/* */`) and `{env:VAR_NAME}` environment variable placeholders.
+
+### Model variants
+
+`variant` (available on both Myrmidons and Titan) selects a **named model preset** that the *provider* defines for a given model — it does **not** change which model runs (that's `model`). Think of it as: `model` picks the model, `variant` picks a named configuration of that model.
+
+How it works in OpenCode:
+
+1. **The provider defines variants.** In your OpenCode provider/model config, a model can declare a `variants` map — a set of named presets (e.g. a reasoning/`thinking` mode, a `fast` mode), each with its own overrides.
+2. **The agent selects one by name.** Setting `variant: "thinking"` on an agent tells OpenCode to run that model using its `thinking` variant.
+
+Notes:
+
+- The value is **not free-form** — it must match a variant key the provider declares for that specific model. If the model has no matching variant, OpenCode has nothing to resolve it against.
+- **Leave `variant` unset** to run the model with its default settings. Most setups don't need it.
+
+### Custom Prompts
+
+Drop prompt files alongside your config to override or extend an agent's system prompt:
+
+| File | Effect |
+|---|---|
+| `titan.md` | **Replaces** Titan's default system prompt entirely |
+| `titan_append.md` | **Appends** to the end of Titan's system prompt |
+
+Search locations:
+
+- **User-level:** `~/.config/opencode/opencode-titan/titan.md`
+- **Project-level:** `.opencode/opencode-titan/titan.md`
+
+## Architecture
+
+```
+src/
+├── index.ts              # Plugin entry — registers agents, hooks, and events
+├── agents/
+│   ├── index.ts          # Agent factory — creates Titan + N Myrmidons
+│   ├── titan.ts          # Titan prompt builder with dynamic Myrmidon descriptions
+│   └── myrmidon.ts       # Myrmidon factory with context-budget constraints
+├── config/
+│   ├── index.ts          # Config exports
+│   ├── schema.ts         # Zod schemas for all config types
+│   ├── loader.ts         # Config loading — JSONC parsing, env vars, deep merge
+│   ├── providers.ts      # Provider resolution helpers
+│   └── constants.ts      # Agent names, delegation reminders
+└── utils/
+    └── provider-lock.ts  # Model-scoped per-provider scheduling lock
+```
+
+The plugin registers hooks in `src/index.ts` to wire everything into OpenCode:
+
+| Hook | Purpose |
+|------|---------|
+| `agent` | Returns the agents record (Titan + Myrmidons) for OpenCode to register |
+| `config` | Sets Titan as the default agent and merges plugin agents into the config |
+| `chat.message` | Tracks which agent is active per session |
+| `experimental.chat.system.transform` | Injects the delegation reminder into Titan's prompt at runtime |
+| `event` | Cleans up session state on `session.deleted` |
+
+## Development
+
+```bash
+bun run build       # Build to dist/
+bun run typecheck   # TypeScript type checking
+bun run lint        # Biome linter
+bun run format      # Biome formatter
+bun run check:ci    # Lint and format (CI mode)
+```
+
+Built with TypeScript, bundled to ESM with esbuild, validated with Zod, and linted/formatted with Biome (80-char lines, 2-space indent, single quotes, trailing commas).
+
+## License
+
+MIT

package/dist/agents/index.d.ts

@@ -0,0 +1,19 @@
+import type { AgentConfig as SDKAgentConfig } from '@opencode-ai/sdk/v2';
+import { type PluginConfig } from '../config';
+import { type AgentDefinition } from './titan';
+/**
+ * Create all agent definitions: Titan + N Myrmidons.
+ *
+ * Each Myrmidon is also registered under its deprecated `child-N` alias so that
+ * existing configs, custom prompts, or sessions that route via the old name
+ * keep working.
+ */
+export declare function createAgents(config?: PluginConfig, options?: {
+    projectDirectory?: string;
+}): AgentDefinition[];
+/**
+ * Get agent configurations formatted for the OpenCode SDK.
+ */
+export declare function getAgentConfigs(config?: PluginConfig, options?: {
+    projectDirectory?: string;
+}): Record<string, SDKAgentConfig>;

package/dist/agents/myrmidon.d.ts

@@ -0,0 +1,8 @@
+import type { MyrmidonConfig } from '../config';
+import type { AgentDefinition } from './titan';
+export declare function createMyrmidonAgent(index: number, config: MyrmidonConfig): AgentDefinition;
+/**
+ * @deprecated Use `createMyrmidonAgent`. Retained as a backwards-compatible
+ * alias for the former "child agent" naming.
+ */
+export declare const createChildAgent: typeof createMyrmidonAgent;

package/dist/agents/titan.d.ts

@@ -0,0 +1,17 @@
+import type { AgentConfig } from '@opencode-ai/sdk/v2';
+import type { MyrmidonConfig } from '../config';
+export interface AgentDefinition {
+    name: string;
+    displayName?: string;
+    description?: string;
+    config: AgentConfig;
+}
+/**
+ * Resolve agent prompt from base/custom/append inputs.
+ */
+export declare function resolvePrompt(base: string, customPrompt?: string, customAppendPrompt?: string): string;
+/**
+ * Build the Titan prompt with Myrmidon descriptions dynamically injected.
+ */
+export declare function buildTitanPrompt(myrmidons: MyrmidonConfig[]): string;
+export declare function createTitanAgent(myrmidons: MyrmidonConfig[], model?: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/config/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const TITAN_AGENT_NAME: "titan";
+export declare const ALL_AGENT_NAMES: readonly ["titan"];
+export type AgentName = (typeof ALL_AGENT_NAMES)[number];
+/** Agents that cannot be disabled. */
+export declare const PROTECTED_AGENTS: Set<"titan">;
+export declare const DELEGATION_REMINDER = "<internal_reminder>DELEGATE EVERYTHING POSSIBLE TO MYRMIDONS. You are the slowest agent by far - your only job is planning, routing, and synthesizing results. Never do work a Myrmidon can handle. Parallelize aggressively: tool calls made in the SAME response turn run concurrently \u2014 always batch all ready task() dispatches into ONE response, never one per turn. SAY WHAT YOU DO: if you announce launching N Myrmidons, emit exactly N task() calls in that same response \u2014 never announce multiple then dispatch only one. Before ending a dispatch turn, count your task() calls and confirm they match the number of Myrmidons you named. The task() tool takes only subagent_type, description, and prompt \u2014 never pass any other parameters. </internal_reminder>";
+/**
+ * Sentinel substring used to detect whether {@link DELEGATION_REMINDER} has
+ * already been injected into a system prompt, avoiding double-injection.
+ */
+export declare const DELEGATION_REMINDER_SENTINEL = "DELEGATE EVERYTHING POSSIBLE TO MYRMIDONS";
+/**
+ * Per-message reminder injected into EVERY user turn addressed to Titan.
+ *
+ * The static system prompt reliably drives delegation on the first request, but
+ * as a conversation shifts to iterating/tweaking the original task, Titan tends
+ * to drift toward doing the work itself. Re-asserting the delegation directive
+ * at the point of each new user message keeps that behavior consistent — it
+ * mimics the user manually prefixing "delegate this" onto every ask.
+ */
+export declare const PER_MESSAGE_DELEGATION_REMINDER = "<delegation_directive>\nBefore you act on the user's message above, STOP and route it through delegation first.\n\n1. Decompose the request (including any follow-up tweaks, fixes, or refinements to prior work) into concrete units of work.\n2. For every unit that would require even a SINGLE tool call \u2014 reading/searching/editing files, running commands, testing, validating, looking things up, gathering information, or any mechanical work \u2014 you MUST delegate it to Myrmidons via task(). This applies to small iterative changes on the existing task just as much as to brand-new work. Do NOT do it yourself because it \"seems quick.\"\n3. Dispatch all independent units in parallel: emit one task() call per unit in a SINGLE response, and make the number of task() calls match the number of Myrmidons you announce.\n4. The ONLY time you may answer directly without delegating is when the request is trivially simple, purely conversational, and requires zero tool calls (e.g., clarifying a question, restating a plan, a one-word answer). When in doubt, delegate.\n\nTreat this as if the user explicitly said: \"delegate this to your Myrmidons.\"\n</delegation_directive>";

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export { deepMerge, loadAgentPrompt, loadPluginConfig, } from './loader';
+export type { AgentLockInfo } from './providers';
+export { buildAgentLockInfoMap, buildAgentProviderMap, resolveChildProvider, resolveMyrmidonProvider, } from './providers';
+export * from './schema';

package/dist/config/loader.d.ts

@@ -0,0 +1,21 @@
+import { type PluginConfig } from './schema';
+export declare function findPluginConfigPaths(directory: string): {
+    userConfigPath: string | null;
+    projectConfigPath: string | null;
+};
+export declare function deepMerge<T extends Record<string, unknown>>(base?: T, override?: T): T | undefined;
+export declare function mergePluginConfigs(base: PluginConfig, override: PluginConfig): PluginConfig;
+/**
+ * Load plugin configuration from user and project config files.
+ */
+export declare function loadPluginConfig(directory: string): PluginConfig;
+/**
+ * Load custom prompt for an agent from the prompts directory.
+ */
+export declare function loadAgentPrompt(agentName: string, options?: {
+    preset?: string;
+    projectDirectory?: string;
+}): {
+    prompt?: string;
+    appendPrompt?: string;
+};

package/dist/config/providers.d.ts

@@ -0,0 +1,46 @@
+import type { MyrmidonConfig } from './schema';
+/**
+ * Resolve the logical provider for a Myrmidon.
+ *
+ * A "provider" here represents the physical backend (machine/host) that serves
+ * the model. Multiple Myrmidons may share a provider when they run on the same
+ * hardware — in which case only one of them can be active at a time (e.g.
+ * because only one model fits in that machine's VRAM at any moment).
+ *
+ * Falls back to the provider prefix of the `provider/model` string when no
+ * explicit `provider` is configured.
+ */
+export declare function resolveMyrmidonProvider(myrmidon: MyrmidonConfig): string;
+/**
+ * @deprecated Use `resolveMyrmidonProvider`. Retained as a backwards-compatible
+ * alias for the former "child agent" naming.
+ */
+export declare const resolveChildProvider: typeof resolveMyrmidonProvider;
+/**
+ * Build a map from Myrmidon agent name to its resolved provider. Each Myrmidon
+ * is registered under its canonical name (`myrmidon-0`, `myrmidon-1`, ...) and
+ * its deprecated alias (`child-0`, `child-1`, ...) so routing keeps working for
+ * either name. The index in the array determines the agent name, matching
+ * `createMyrmidonAgent`.
+ */
+export declare function buildAgentProviderMap(myrmidons: MyrmidonConfig[]): Map<string, string>;
+/**
+ * Runtime lock metadata for a Myrmidon.
+ *
+ * `provider` is the physical backend; `model` identifies what is loaded into
+ * that backend's VRAM. Multiple instances of the *same* model may run
+ * concurrently on a provider (up to `maxInstances`), but different models on the
+ * same provider must be serialized.
+ */
+export interface AgentLockInfo {
+    provider: string;
+    model: string;
+    maxInstances: number;
+}
+/**
+ * Build a map from Myrmidon agent name to the lock metadata used to enforce the
+ * per-provider, per-model concurrency constraint at runtime. Both the canonical
+ * name (`myrmidon-N`) and the deprecated alias (`child-N`) are registered so
+ * the runtime lock applies regardless of which routing name is used.
+ */
+export declare function buildAgentLockInfoMap(myrmidons: MyrmidonConfig[]): Map<string, AgentLockInfo>;

package/dist/config/schema.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+export declare const ProviderModelIdSchema: z.ZodString;
+export declare const ModelTypeSchema: z.ZodEnum<{
+    dense: "dense";
+    sparse: "sparse";
+}>;
+export type ModelType = z.infer<typeof ModelTypeSchema>;
+export declare const MyrmidonConfigSchema: z.ZodObject<{
+    model: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    speed: z.ZodNumber;
+    intelligence: z.ZodNumber;
+    modelType: z.ZodEnum<{
+        dense: "dense";
+        sparse: "sparse";
+    }>;
+    maxInstances: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type MyrmidonConfig = z.infer<typeof MyrmidonConfigSchema>;
+/**
+ * @deprecated Use `MyrmidonConfigSchema`. Retained as a backwards-compatible
+ * alias for the former "child agent" naming.
+ */
+export declare const ChildAgentConfigSchema: z.ZodObject<{
+    model: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    speed: z.ZodNumber;
+    intelligence: z.ZodNumber;
+    modelType: z.ZodEnum<{
+        dense: "dense";
+        sparse: "sparse";
+    }>;
+    maxInstances: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * @deprecated Use `MyrmidonConfig`. Retained as a backwards-compatible alias
+ * for the former "child agent" naming.
+ */
+export type ChildAgentConfig = MyrmidonConfig;
+export declare const TitanOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TitanOverrideConfig = z.infer<typeof TitanOverrideConfigSchema>;
+export declare const PluginConfigSchema: z.ZodObject<{
+    titan: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    myrmidons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        model: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        speed: z.ZodNumber;
+        intelligence: z.ZodNumber;
+        modelType: z.ZodEnum<{
+            dense: "dense";
+            sparse: "sparse";
+        }>;
+        maxInstances: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        model: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        speed: z.ZodNumber;
+        intelligence: z.ZodNumber;
+        modelType: z.ZodEnum<{
+            dense: "dense";
+            sparse: "sparse";
+        }>;
+        maxInstances: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    disabled_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backgroundJobs: z.ZodOptional<z.ZodObject<{
+        maxSessionsPerAgent: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginConfig = z.infer<typeof PluginConfigSchema>;
+/**
+ * Resolve the configured Myrmidon fleet, honoring the deprecated `children`
+ * key. `myrmidons` takes precedence when both are provided.
+ */
+export declare function getMyrmidonConfigs(config?: PluginConfig): MyrmidonConfig[];

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@opencode-ai/plugin';
+declare const OpenCodeDistributedDelegation: Plugin;
+export default OpenCodeDistributedDelegation;
+export type { ChildAgentConfig, ModelType, MyrmidonConfig, PluginConfig, } from './config';