opencode-titan 0.1.0

package/dist/index.js

@@ -0,0 +1,852 @@
+// src/config/constants.ts
+var TITAN_AGENT_NAME = "titan";
+var 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>`;
+var DELEGATION_REMINDER_SENTINEL = "DELEGATE EVERYTHING POSSIBLE TO MYRMIDONS";
+var PER_MESSAGE_DELEGATION_REMINDER = `<delegation_directive>
+Before you act on the user's message above, STOP and route it through delegation first.
+
+1. Decompose the request (including any follow-up tweaks, fixes, or refinements to prior work) into concrete units of work.
+2. 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."
+3. 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.
+4. 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.
+
+Treat this as if the user explicitly said: "delegate this to your Myrmidons."
+</delegation_directive>`;
+
+// src/config/loader.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderModelIdSchema = z.string().regex(
+  /^[^/\s]+\/[^\s]+$/,
+  "Expected provider/model format (provider/.../model)"
+);
+var ModelTypeSchema = z.enum(["dense", "sparse"]);
+var MyrmidonConfigSchema = z.object({
+  model: z.union([ProviderModelIdSchema, z.string()]),
+  speed: z.number().int().min(1).max(10),
+  intelligence: z.number().int().min(1).max(10),
+  modelType: ModelTypeSchema,
+  // Maximum number of parallel instances Titan may run for this Myrmidon.
+  // Because instances share the same model (already loaded in the provider's
+  // VRAM), they can run concurrently on the same provider. Defaults to 1.
+  maxInstances: z.number().int().min(1).optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  variant: z.string().optional(),
+  displayName: z.string().min(1).optional(),
+  provider: z.string().min(1).optional()
+}).strict();
+var TitanOverrideConfigSchema = z.object({
+  model: z.union([ProviderModelIdSchema, z.string()]).optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  variant: z.string().optional(),
+  prompt: z.string().min(1).optional()
+}).strict();
+var PluginConfigSchema = z.object({
+  titan: TitanOverrideConfigSchema.optional(),
+  // Preferred: the Myrmidon fleet Titan delegates work to.
+  myrmidons: z.array(MyrmidonConfigSchema).optional(),
+  // Deprecated alias for `myrmidons`, retained for backwards compatibility.
+  // If both are present, `myrmidons` takes precedence.
+  children: z.array(MyrmidonConfigSchema).optional(),
+  disabled_tools: z.array(z.string()).optional(),
+  backgroundJobs: z.object({
+    maxSessionsPerAgent: z.number().int().min(1).max(10).default(10)
+  }).optional()
+});
+function getMyrmidonConfigs(config) {
+  return config?.myrmidons ?? config?.children ?? [];
+}
+
+// src/config/loader.ts
+var PROMPTS_DIR_NAME = "opencode-titan";
+function stripJsonComments(content) {
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    const ch = content[i];
+    const next = content[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") {
+        inLineComment = false;
+        result += ch;
+      }
+      i++;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (inString) {
+      result += ch;
+      if (ch === "\\" && content[i + 1]) {
+        result += content[i + 1];
+        i += 2;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLineComment = true;
+      i += 2;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 2;
+      continue;
+    }
+    result += ch;
+    i++;
+  }
+  return result;
+}
+function loadConfigFromPath(configPath) {
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    let rawConfig;
+    try {
+      const stripped = stripJsonComments(content);
+      const interpolated = stripped.replace(
+        /\{env:([^}]+)\}/g,
+        (_, varName) => process.env[varName] ?? ""
+      );
+      rawConfig = JSON.parse(interpolated);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(
+        `[opencode-titan] FATAL: Invalid JSON in ${configPath}: ${msg}
+  Titan will have NO Myrmidons until this is fixed.`
+      );
+      return null;
+    }
+    const result = PluginConfigSchema.safeParse(rawConfig);
+    if (!result.success) {
+      console.error(
+        `[opencode-titan] FATAL: Config schema validation failed at ${configPath}:
+  Titan will have NO Myrmidons until this is fixed.`
+      );
+      console.error(result.error.format());
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+      console.warn(
+        `[opencode-titan] Error reading config from ${configPath}:`,
+        error.message
+      );
+    }
+    return null;
+  }
+}
+function findConfigPath(basePath) {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+  if (fs.existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+  if (fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+  return null;
+}
+function getConfigSearchDirs() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  if (xdgConfig) {
+    return [path.join(xdgConfig, "opencode")];
+  }
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  if (!home) return [];
+  return [path.join(home, ".config", "opencode"), path.join(home, ".opencode")];
+}
+function findConfigPathInDirs(configDirs, baseName) {
+  for (const configDir of configDirs) {
+    const configPath = findConfigPath(path.join(configDir, baseName));
+    if (configPath) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function findPluginConfigPaths(directory) {
+  const userConfigPath = findConfigPathInDirs(
+    getConfigSearchDirs(),
+    "opencode-titan"
+  );
+  const projectConfigBasePath = path.join(
+    directory,
+    ".opencode",
+    "opencode-titan"
+  );
+  const projectConfigPath = findConfigPath(projectConfigBasePath);
+  return { userConfigPath, projectConfigPath };
+}
+function deepMerge(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (typeof baseVal === "object" && baseVal !== null && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(baseVal) && !Array.isArray(overrideVal)) {
+      result[key] = deepMerge(
+        baseVal,
+        overrideVal
+      );
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function mergePluginConfigs(base, override) {
+  return {
+    ...base,
+    ...override,
+    titan: deepMerge(base.titan, override.titan),
+    backgroundJobs: deepMerge(base.backgroundJobs, override.backgroundJobs)
+  };
+}
+function loadPluginConfig(directory) {
+  const { userConfigPath, projectConfigPath } = findPluginConfigPaths(directory);
+  let config = userConfigPath ? loadConfigFromPath(userConfigPath) ?? {} : {};
+  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath) : null;
+  if (projectConfig) {
+    config = mergePluginConfigs(config, projectConfig);
+  }
+  return config;
+}
+function loadAgentPrompt(agentName, options) {
+  const projectDirectory = options?.projectDirectory;
+  const searchDirs = [];
+  if (projectDirectory) {
+    searchDirs.push(path.join(projectDirectory, ".opencode", PROMPTS_DIR_NAME));
+  }
+  for (const userDir of getConfigSearchDirs()) {
+    searchDirs.push(path.join(userDir, PROMPTS_DIR_NAME));
+  }
+  const readFirstPrompt = (fileName) => {
+    for (const dir of searchDirs) {
+      const promptPath = path.join(dir, fileName);
+      if (!fs.existsSync(promptPath)) continue;
+      try {
+        return fs.readFileSync(promptPath, "utf-8");
+      } catch {
+      }
+    }
+    return void 0;
+  };
+  return {
+    prompt: readFirstPrompt(`${agentName}.md`),
+    appendPrompt: readFirstPrompt(`${agentName}_append.md`)
+  };
+}
+
+// src/config/providers.ts
+function resolveMyrmidonProvider(myrmidon) {
+  return myrmidon.provider ?? myrmidon.model.split("/")[0];
+}
+function buildAgentLockInfoMap(myrmidons) {
+  const map = /* @__PURE__ */ new Map();
+  myrmidons.forEach((myrmidon, idx) => {
+    const info = {
+      provider: resolveMyrmidonProvider(myrmidon),
+      model: myrmidon.model,
+      maxInstances: myrmidon.maxInstances ?? 1
+    };
+    map.set(`myrmidon-${idx}`, info);
+    map.set(`child-${idx}`, info);
+  });
+  return map;
+}
+
+// src/agents/myrmidon.ts
+var MYRMIDON_PROMPT_TEMPLATE = `You are a Myrmidon working under Titan, the primary orchestrator.
+
+**Your Role**: Execute a single, bounded task delegated by Titan. You are fast and efficient. You must be surgical \u2014 do not over-explore.
+
+<ContextBudget>
+You are operating with a hard context budget. Exceeding it causes failure. Follow these rules without exception:
+
+- **Tool call limit: 25 calls maximum.** Stop and report with what you have if you reach this limit.
+- **Stop as soon as you have enough to answer.** Do not keep exploring once the answer is clear.
+- **Prefer targeted tools over broad reads.** grep/search before reading files. Never read a full file when a line-range or search suffices.
+- **Read sections, not whole files.** Use line ranges (e.g., lines 10\u201350) rather than reading entire files.
+- **Do not recurse.** If a search leads to more files, pick the most relevant 1\u20132 and stop. Do not chain indefinitely.
+- **Do not validate or test beyond what's asked.** If Titan asked you to find something, find it and stop. Do not run extra checks speculatively.
+- If you are approaching the tool call limit and still uncertain, report partial findings clearly rather than continuing.
+</ContextBudget>
+
+<OutputConstraints>
+- **CRITICAL: Your final response to Titan MUST be ONE PARAGRAPH, no more than 500 words.**
+- No preamble, no summary of what you did \u2014 just the results.
+- Report success/failure clearly in your first sentence.
+- Include only actionable details: file paths, line numbers, errors, generated code snippets.
+- Titan is slow; verbose responses waste its inference budget.
+</OutputConstraints>
+
+<Behavior>
+- Execute the task precisely as described \u2014 nothing more, nothing less
+- Make reasonable assumptions when ambiguous; note them in one sentence
+- If the task is already done or the answer is obvious from context, say so immediately without invoking tools
+</Behavior>
+
+<Task>
+{{TASK_PROMPT}}
+</Task>
+`;
+function createMyrmidonAgent(index, config) {
+  const name = `myrmidon-${index}`;
+  const modelTypeHint = config.modelType === "dense" ? "You are running a dense model \u2014 you excel at logic, reasoning, and complex problem-solving. Use this strength for tasks requiring careful analysis." : "You are running a sparse model \u2014 you excel at fast information gathering, broad search, and rapid lookups. Use this strength for research and exploration tasks.";
+  const prompt = `${MYRMIDON_PROMPT_TEMPLATE.replace("{{TASK_PROMPT}}", "")}
+
+${modelTypeHint}`;
+  return {
+    name,
+    displayName: config.displayName,
+    description: buildMyrmidonDescription(index, config),
+    config: {
+      model: config.model,
+      temperature: config.temperature ?? 0.1,
+      ...config.variant ? { variant: config.variant } : {},
+      prompt,
+      mode: "subagent"
+    }
+  };
+}
+function buildMyrmidonDescription(index, config) {
+  const typeLabel = config.modelType === "dense" ? "logic & reasoning specialist" : "information gathering specialist";
+  return `Myrmidon #${index} (${typeLabel}). Speed: ${config.speed}/10, Intelligence: ${config.intelligence}/10. Model: ${config.model}.`;
+}
+
+// src/agents/titan.ts
+function resolvePrompt(base, customPrompt, customAppendPrompt) {
+  const effectiveBase = customPrompt !== void 0 ? customPrompt : base;
+  return customAppendPrompt !== void 0 ? `${effectiveBase}
+
+${customAppendPrompt}` : effectiveBase;
+}
+function buildTitanPrompt(myrmidons) {
+  const resolveProvider = resolveMyrmidonProvider;
+  const myrmidonDescriptions = myrmidons.map((myrmidon, idx) => {
+    const name = `myrmidon-${idx}`;
+    const provider = resolveProvider(myrmidon);
+    const maxInstances = myrmidon.maxInstances ?? 1;
+    return `<Myrmidon>
+- **Name:** @${name}
+- **subagent_type:** \`"${name}"\` \u2190 use this exact string in task(subagent_type: "${name}", ...)
+- **Model:** ${myrmidon.model}
+- **Provider:** ${provider}
+- **Max Instances:** ${maxInstances}${maxInstances > 1 ? ` (you may run up to ${maxInstances} tasks on @${name} AT THE SAME TIME \u2014 treat it like ${maxInstances} distinct Myrmidons)` : " (single instance \u2014 one task at a time)"}
+- **Speed:** ${myrmidon.speed}/10 (${myrmidon.speed >= 7 ? "fast" : myrmidon.speed >= 4 ? "moderate" : "slow"})
+- **Intelligence:** ${myrmidon.intelligence}/10 (${myrmidon.intelligence >= 7 ? "strong reasoning" : myrmidon.intelligence >= 4 ? "adequate reasoning" : "limited reasoning"})
+- **Model Type:** ${myrmidon.modelType} (${myrmidon.modelType === "dense" ? "better at logic, planning, complex problem-solving" : "better at information gathering, fast lookups, broad search"})
+${myrmidon.displayName ? `- **Display Name:** ${myrmidon.displayName}` : ""}
+</Myrmidon>`;
+  }).join("\n\n");
+  const hasDense = myrmidons.some((m) => m.modelType === "dense");
+  const hasSparse = myrmidons.some((m) => m.modelType === "sparse");
+  const hasHighIntel = myrmidons.some((m) => m.intelligence >= 7);
+  const hasHighSpeed = myrmidons.some((m) => m.speed >= 7);
+  const capabilityGuidance = [];
+  if (hasDense) {
+    capabilityGuidance.push(
+      "- Dense Myrmidons: delegate logic-heavy tasks, complex code generation, debugging strategy, architectural reasoning"
+    );
+  }
+  if (hasSparse) {
+    capabilityGuidance.push(
+      "- Sparse Myrmidons: delegate information gathering, documentation lookups, broad codebase exploration, web research"
+    );
+  }
+  if (hasHighIntel) {
+    capabilityGuidance.push(
+      "- High-intelligence Myrmidons (7+): can handle multi-step reasoning tasks independently; trust them with complex sub-tasks"
+    );
+  }
+  if (hasHighSpeed) {
+    capabilityGuidance.push(
+      "- High-speed Myrmidons (7+): prioritize for time-sensitive lookups and rapid iterations; spawn multiple for parallel work"
+    );
+  }
+  const providerToMyrmidons = /* @__PURE__ */ new Map();
+  myrmidons.forEach((myrmidon, idx) => {
+    const p = resolveProvider(myrmidon);
+    providerToMyrmidons.set(p, [
+      ...providerToMyrmidons.get(p) ?? [],
+      `@myrmidon-${idx}`
+    ]);
+  });
+  const sharedProviders = [...providerToMyrmidons.entries()].filter(([, agents]) => agents.length > 1).map(
+    ([provider, agents]) => `- **${provider}** hosts ${agents.length} DIFFERENT models: ${agents.join(", ")}. You may dispatch to AT MOST ONE of these per turn. Dispatching two or more of them "in parallel" does NOT parallelize \u2014 the runtime force-serializes them (the second waits for the first to fully finish), so you gain nothing and stall your fleet. Pick exactly one; send the other's work to a Myrmidon on a DIFFERENT provider instead.`
+  );
+  const selfParallelMyrmidons = myrmidons.map((myrmidon, idx) => ({ myrmidon, idx })).filter(({ myrmidon }) => (myrmidon.maxInstances ?? 1) > 1).map(
+    ({ myrmidon, idx }) => `- @myrmidon-${idx}: up to ${myrmidon.maxInstances} instances in parallel (same model on ${resolveProvider(myrmidon)} \u2014 safe to load once, run many)`
+  );
+  return `<Role>
+You are Titan \u2014 the most intelligent and capable agent in this system, but also by far the slowest. You are borderline unusably slow on this hardware. Your survival depends on one rule:
+
+**NEVER DO WORK A MYRMIDON CAN HANDLE.**
+
+You are a commander, not a worker. Your only responsibilities are: planning, routing, quality-gating, and synthesizing results from your Myrmidons. Every other action \u2014 reading files, searching code, writing code, testing ideas, validating syntax, looking up documentation, running diagnostics \u2014 must be delegated to a Myrmidon.
+
+You have ${myrmidons.length} Myrmidons available:
+
+${myrmidonDescriptions}
+
+${sharedProviders.length > 0 ? `
+**\u26A0\uFE0F PROVIDER CONFLICTS \u2014 READ BEFORE EVERY DISPATCH \u26A0\uFE0F**
+Each line below is a group of mutually-exclusive Myrmidons that share one physical backend. Only one model fits in that backend's VRAM at a time. Treat each group as a "pick at most ONE per turn" constraint:
+${sharedProviders.join("\n")}
+
+Before you emit a batch of task() calls, scan your chosen Myrmidons against these groups. If your batch contains two Myrmidons from the same group, it is WRONG \u2014 drop one and replace it with a Myrmidon on a free provider (or defer that work to a later turn).` : ""}
+
+${selfParallelMyrmidons.length > 0 ? `**Self-parallel Myrmidons (same model, safe to run multiple copies at once):**
+${selfParallelMyrmidons.join("\n")}` : ""}
+
+</Role>
+
+<DelegationPhilosophy>
+## The Golden Rule
+If a task can be abstracted away to a Myrmidon, it MUST be. No exceptions. This includes:
+- Looking up things in the code
+- Testing ideas
+- Writing code
+- Validating syntax
+- Reading documentation
+- Running diagnostics
+- Searching for patterns
+- Any information gathering
+- Any mechanical implementation
+
+## Parallelization is Key
+You are slow. Your Myrmidons are fast \u2014 sometimes 50x faster. You have **${myrmidons.length} Myrmidon${myrmidons.length !== 1 ? "s" : ""}**. There is NO cap on how many you can run at once \u2014 dispatch all of them simultaneously if the work warrants it.
+
+**You must never artificially cap dispatches at 2.** If there are 3, 4, or 5 independent tasks, dispatch 3, 4, or 5 Myrmidons in one turn.
+
+Examples:
+- 3 independent investigation tasks \u2192 dispatch @myrmidon-0, @myrmidon-1, and @myrmidon-2 in ONE response.
+- 5 files to analyze \u2192 dispatch one Myrmidon per file, all in ONE response.
+- Mix of coding + research + validation \u2192 dispatch a Myrmidon for each, all at once.
+
+Identify idle Myrmidons before acting on anything yourself.
+
+### Provider Constraint
+A provider is a physical backend that can hold only ONE model in VRAM at a time. This drives two rules:
+
+1. **Different models on the same provider CANNOT run in parallel \u2014 ever.** If two Myrmidons share a provider (different models), you may dispatch to only ONE of them per turn. Dispatching both in the same batch does NOT run them concurrently: the runtime force-serializes them, so the second silently waits for the first to finish. You get zero parallelism AND you've wasted a dispatch slot you could have given to a genuinely-free Myrmidon. Always check the "PROVIDER CONFLICTS" groups above before batching.
+2. **The same model on a provider CAN run in parallel.** A Myrmidon with **Max Instances > 1** may receive that many task() calls AT ONCE \u2014 the model is already loaded, so extra instances cost nothing. Treat such a Myrmidon as if it were N distinct Myrmidons: issue up to N task(subagent_type: "myrmidon-K", ...) calls for it in the SAME response.
+
+**Mandatory pre-dispatch self-check:** Before emitting a batch of task() calls, list the Myrmidons you're about to use and confirm no two of them belong to the same provider-conflict group. If two do, replace one with a Myrmidon on a different (free) provider, or move its work to a later turn. Real parallelism only happens across distinct providers (plus same-model instances). Two Myrmidons on one backend = sequential, no matter how you dispatch them.
+
+Example: providers A and B, where @myrmidon-0 (provider A, maxInstances=2), @myrmidon-1 (provider A), @myrmidon-2 (provider B). To split work into 3 parallel tasks, dispatch TWO tasks to @myrmidon-0 (its 2 instances) plus ONE task to @myrmidon-2 \u2014 all in one response. Do NOT also dispatch @myrmidon-1, because it's a different model on provider A and would collide with @myrmidon-0's VRAM (it would just queue behind @myrmidon-0).
+
+## Matching Tasks to Myrmidons
+${capabilityGuidance.join("\n")}
+
+## Task Sizing
+- Break large tasks into smaller, parallelizable sub-tasks
+- Each Myrmidon should receive a clear, bounded objective
+- Reference file paths and line numbers instead of pasting full file contents
+- Provide enough context for the Myrmidon to succeed independently
+
+</DelegationPhilosophy>
+
+<Workflow>
+## 1. Parse
+Understand the request: explicit requirements + implicit needs. Identify all independent work streams.
+
+## 2. Plan
+Build a minimal work graph:
+- Which tasks can run in parallel immediately?
+- Which tasks depend on others?
+- Which Myrmidon is best suited for each task based on speed, intelligence, and model type?
+
+## 3. Dispatch
+Launch ALL independent tasks in a single response using the task() tool.
+
+**CRITICAL \u2014 routing to a Myrmidon**: The task() tool requires a \`subagent_type\` parameter that must be set to the Myrmidon's name to route work to that Myrmidon. Without it, work stays with you (Titan). Always specify it explicitly:
+
+\`\`\`
+task(
+  subagent_type: "myrmidon-0",   // \u2190 REQUIRED: routes the task to that Myrmidon
+  description: "short label",
+  prompt: "detailed task instructions..."
+)
+\`\`\`
+
+- \`subagent_type\` must exactly match the Myrmidon's name: \`"myrmidon-0"\`, \`"myrmidon-1"\`, etc.
+- \`description\` and \`prompt\` are the only other parameters. Do NOT pass any other fields (no \`background\`, no \`taskId\`, etc.) \u2014 the tool rejects unknown parameters.
+- Never omit \`subagent_type\` \u2014 omitting it means Titan does the work itself, defeating delegation.
+- The task() tool is synchronous: each call blocks until the Myrmidon finishes and returns its result. To run Myrmidons concurrently, issue multiple task() calls in the same response (see below).
+
+**CRITICAL \u2014 how parallelism works**: Tool calls issued within the **same response turn** execute concurrently. Tool calls issued in separate response turns execute sequentially. This means:
+- \u2705 PARALLEL: Issue task() for myrmidon-0 AND task() for myrmidon-1 in ONE response \u2192 both run at the same time.
+- \u274C SEQUENTIAL: Issue task() for myrmidon-0, wait for the next turn, then issue task() for myrmidon-1 \u2192 they run one after the other.
+
+**Never send a single task() call per turn when you have multiple independent tasks.** Always batch all ready dispatches into one response. Plan first (mentally), then emit all the task() calls in one shot. Do not narrate between calls \u2014 dispatch, then stop.
+
+**CRITICAL \u2014 say what you do, do what you say (avoid the "announce many, dispatch one" trap)**: A common and serious failure is announcing "Dispatching @myrmidon-0, @myrmidon-1, and @myrmidon-2 in parallel..." and then emitting only ONE task() call before ending your turn. This wastes an entire round-trip and forces the user to correct you. It is strictly forbidden. Enforce this self-check on every dispatch:
+- The number of task() calls in your response MUST equal the number of Myrmidons you name in your announcement. If you say you are launching 3 Myrmidons, your response MUST contain 3 task() calls.
+- Do NOT end your turn after the first task() call if more independent tasks remain. Keep emitting task() calls in the SAME response until every ready task is dispatched.
+- Prefer to emit ALL task() calls first, then a one-line note \u2014 or skip the note entirely. Never let a sentence of narration cause you to stop before the remaining calls are made.
+- If you are only going to dispatch one Myrmidon, then announce only one Myrmidon. Your words and your tool calls must always match.
+
+Before you finish a dispatch turn, silently count: "Independent tasks ready = N. task() calls I just emitted = N?" If they don't match, emit the missing calls now \u2014 do not wait for the next turn.
+
+## 4. Monitor
+Each task() call returns the Myrmidon's result when it completes. When you dispatch several Myrmidons in one response, you receive all their results together before your next turn.
+
+## 5. Synthesize
+When Myrmidons report back, integrate their results into a coherent outcome. If something is missing or wrong, re-delegate \u2014 don't do it yourself.
+
+## 6. Verify
+Use a Myrmidon to run checks/diagnostics/validations. Only you decide if the output meets requirements, but delegate the actual verification work.
+</Workflow>
+
+<CommunicationWithUser>
+- Answer directly, no preamble
+- Brief delegation notices: "Dispatching @myrmidon-0 and @myrmidon-1 in parallel..." not lengthy explanations. Emit the task() calls in the same response \u2014 a delegation notice with no matching calls, or fewer calls than named, is a bug.
+- One-word answers are fine when appropriate
+- Never: "Great question!" or any praise of user input
+- If the request is vague, ask a targeted question before proceeding
+</CommunicationWithUser>
+
+<CommunicationWithMyrmidons>
+When delegating to a Myrmidon:
+- Be specific about the task and expected output format
+- Reference file paths/lines, don't paste full contents
+- Set clear boundaries: what to do and what not to do
+- Tell the Myrmidon to report back concisely (one paragraph, under 500 words max)
+</CommunicationWithMyrmidons>
+
+${DELEGATION_REMINDER}
+`;
+}
+function createTitanAgent(myrmidons, model, customPrompt, customAppendPrompt) {
+  const basePrompt = buildTitanPrompt(myrmidons);
+  const prompt = resolvePrompt(basePrompt, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "titan",
+    description: "Primary orchestrator \u2014 plans, delegates, and synthesizes. Delegates everything possible to faster Myrmidons.",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+
+// src/agents/index.ts
+function createAgents(config, options) {
+  const myrmidons = getMyrmidonConfigs(config);
+  const titanModel = config?.titan?.model;
+  const titanPrompts = loadAgentPrompt("titan", {
+    projectDirectory: options?.projectDirectory
+  });
+  const titan = createTitanAgent(
+    myrmidons,
+    typeof titanModel === "string" ? titanModel : void 0,
+    config?.titan?.prompt,
+    void 0
+  );
+  titan.config.prompt = resolvePrompt(
+    titan.config.prompt ?? "",
+    titanPrompts.prompt,
+    titanPrompts.appendPrompt
+  );
+  if (config?.titan) {
+    if (config.titan.temperature !== void 0) {
+      titan.config.temperature = config.titan.temperature;
+    }
+    if (config.titan.variant) {
+      titan.config.variant = config.titan.variant;
+    }
+  }
+  const myrmidonAgents = myrmidons.map(
+    (myrmidonConfig, idx) => createMyrmidonAgent(idx, myrmidonConfig)
+  );
+  const aliasAgents = myrmidonAgents.map((agent, idx) => ({
+    ...agent,
+    name: `child-${idx}`,
+    description: `[Deprecated alias of @myrmidon-${idx}] ${agent.description ?? ""}`.trim()
+  }));
+  return [titan, ...myrmidonAgents, ...aliasAgents];
+}
+function getAgentConfigs(config, options) {
+  const agents = createAgents(config, options);
+  const entries = [];
+  for (const agent of agents) {
+    const sdkConfig = {
+      ...agent.config,
+      description: agent.description
+    };
+    if (agent.name === TITAN_AGENT_NAME) {
+      sdkConfig.mode = "primary";
+    } else {
+      sdkConfig.mode = "subagent";
+    }
+    if (agent.displayName) {
+      sdkConfig.displayName = agent.displayName;
+    }
+    entries.push([agent.name, sdkConfig]);
+  }
+  return Object.fromEntries(entries);
+}
+
+// src/utils/provider-lock.ts
+var ProviderLockManager = class {
+  providers = /* @__PURE__ */ new Map();
+  /**
+   * Acquire a slot for `model` on `provider`. Resolves with an idempotent
+   * release function once a slot is available.
+   *
+   * @param provider      Logical provider (physical backend) identifier.
+   * @param model         The model to load — same-model acquisitions can share
+   *                      the provider concurrently.
+   * @param maxConcurrent Maximum concurrent instances of this model (>= 1).
+   */
+  acquire(provider, model, maxConcurrent = 1) {
+    const state = this.getState(provider);
+    return new Promise((resolve) => {
+      state.queue.push({
+        model,
+        maxConcurrent: Math.max(1, Math.floor(maxConcurrent)),
+        grant: resolve
+      });
+      this.pump(provider);
+    });
+  }
+  getState(provider) {
+    let state = this.providers.get(provider);
+    if (!state) {
+      state = { activeModel: null, activeCount: 0, queue: [] };
+      this.providers.set(provider, state);
+    }
+    return state;
+  }
+  /**
+   * Grant as many queued waiters as the current provider state allows. Only the
+   * queue head is considered each step to preserve FIFO fairness (a different
+   * model cannot be skipped by later same-model waiters).
+   */
+  pump(provider) {
+    const state = this.providers.get(provider);
+    if (!state) return;
+    while (state.queue.length > 0) {
+      const head = state.queue[0];
+      const canGrant = state.activeModel === null || state.activeModel === head.model && state.activeCount < head.maxConcurrent;
+      if (!canGrant) break;
+      state.queue.shift();
+      state.activeModel = head.model;
+      state.activeCount++;
+      head.grant(this.makeRelease(provider, state));
+    }
+  }
+  makeRelease(provider, state) {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      state.activeCount--;
+      if (state.activeCount <= 0) {
+        state.activeCount = 0;
+        state.activeModel = null;
+        if (state.queue.length === 0 && this.providers.get(provider) === state) {
+          this.providers.delete(provider);
+          return;
+        }
+      }
+      this.pump(provider);
+    };
+  }
+};
+
+// src/index.ts
+var PROVIDER_LOCK_TIMEOUT_MS = 30 * 60 * 1e3;
+var OpenCodeDistributedDelegation = async (ctx) => {
+  let config;
+  let agents;
+  let sessionAgentMap;
+  let providerLocks;
+  let agentLockInfoMap;
+  try {
+    config = loadPluginConfig(ctx.directory);
+    agents = getAgentConfigs(config, { projectDirectory: ctx.directory });
+    sessionAgentMap = /* @__PURE__ */ new Map();
+    providerLocks = new ProviderLockManager();
+    agentLockInfoMap = buildAgentLockInfoMap(getMyrmidonConfigs(config));
+  } catch (err) {
+    console.error(`[opencode-titan] FATAL: init failed: ${err}`);
+    throw err;
+  }
+  const myrmidonCount = getMyrmidonConfigs(config).length;
+  if (myrmidonCount < 1) {
+    console.warn(
+      "[opencode-titan] WARN: No Myrmidons configured. Titan cannot delegate without Myrmidons. Add myrmidons to your config."
+    );
+  }
+  const heldLocks = /* @__PURE__ */ new Map();
+  const lockKey = (sessionID, callID) => `${sessionID}:${callID}`;
+  const releaseLock = (key) => {
+    const held = heldLocks.get(key);
+    if (!held) return;
+    heldLocks.delete(key);
+    clearTimeout(held.timer);
+    held.release();
+  };
+  return {
+    name: "opencode-titan",
+    agent: agents,
+    // Enforce the provider constraint at runtime. A Myrmidon's provider
+    // represents the physical backend serving its model; a backend can only
+    // hold ONE model in VRAM at a time. So different models on the same
+    // provider are serialized, while up to `maxInstances` instances of the SAME
+    // model may run concurrently. Acquiring a per-provider, model-aware slot
+    // before the subagent starts and releasing it after enforces this even when
+    // Titan dispatches tasks "in parallel".
+    "tool.execute.before": async (input, output) => {
+      if (input.tool !== "task") return;
+      const args = output.args;
+      const subagentType = args?.subagent_type;
+      if (!subagentType) return;
+      const lockInfo = agentLockInfoMap.get(subagentType);
+      if (!lockInfo) return;
+      const { provider, model, maxInstances } = lockInfo;
+      const key = lockKey(input.sessionID, input.callID);
+      if (heldLocks.has(key)) return;
+      const release = await providerLocks.acquire(
+        provider,
+        model,
+        maxInstances
+      );
+      const timer = setTimeout(() => {
+        if (heldLocks.has(key)) {
+          console.warn(
+            `[opencode-titan] WARN: provider lock for "${provider}" (${key}) auto-released after timeout; the task may have been interrupted.`
+          );
+          releaseLock(key);
+        }
+      }, PROVIDER_LOCK_TIMEOUT_MS);
+      timer.unref?.();
+      heldLocks.set(key, { provider, release, timer });
+    },
+    // Release the provider lock once the subagent task completes (or errors).
+    "tool.execute.after": async (input) => {
+      if (input.tool !== "task") return;
+      releaseLock(lockKey(input.sessionID, input.callID));
+    },
+    config: async (opencodeConfig) => {
+      if (!opencodeConfig.default_agent) {
+        opencodeConfig.default_agent = TITAN_AGENT_NAME;
+      }
+      if (!opencodeConfig.agent) {
+        opencodeConfig.agent = { ...agents };
+      } else {
+        for (const [name, pluginAgent] of Object.entries(agents)) {
+          const existing = opencodeConfig.agent[name];
+          if (existing) {
+            opencodeConfig.agent[name] = {
+              ...pluginAgent,
+              ...existing
+            };
+          } else {
+            opencodeConfig.agent[name] = {
+              ...pluginAgent
+            };
+          }
+        }
+      }
+    },
+    // Track which agent each session uses for serve-mode prompt injection,
+    // and re-assert the delegation directive on every user turn to Titan.
+    "chat.message": async (input, output) => {
+      const agent = input.agent ?? output?.message?.agent;
+      if (agent) {
+        sessionAgentMap.set(input.sessionID, agent);
+      }
+      if (agent !== TITAN_AGENT_NAME || !output?.parts) {
+        return;
+      }
+      const alreadyInjected = output.parts.some(
+        (p) => p && p.type === "text" && typeof p.text === "string" && p.text.includes("<delegation_directive>")
+      );
+      if (alreadyInjected) {
+        return;
+      }
+      output.parts.push({
+        id: `prt_deleg_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+        sessionID: input.sessionID,
+        messageID: output.message?.id ?? "",
+        type: "text",
+        text: PER_MESSAGE_DELEGATION_REMINDER,
+        synthetic: true
+      });
+    },
+    // Inject delegation reminder for Titan in serve-mode sessions
+    "experimental.chat.system.transform": async (input, output) => {
+      const agentName = input.sessionID ? sessionAgentMap.get(input.sessionID) : void 0;
+      if (agentName === TITAN_AGENT_NAME) {
+        const alreadyInjected = output.system.some(
+          (s) => typeof s === "string" && s.includes(DELEGATION_REMINDER_SENTINEL)
+        );
+        if (!alreadyInjected) {
+          if (output.system.length > 0) {
+            const lastIdx = output.system.length - 1;
+            const last = output.system[lastIdx];
+            if (typeof last === "string") {
+              output.system[lastIdx] = `${last}
+
+${DELEGATION_REMINDER}`;
+            }
+          }
+        }
+      }
+    },
+    // Clean up session tracking on deletion
+    event: async (input) => {
+      const event = input.event;
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        const sessionID = props?.info?.id ?? props?.sessionID;
+        if (sessionID) {
+          sessionAgentMap.delete(sessionID);
+          for (const key of [...heldLocks.keys()]) {
+            if (key.startsWith(`${sessionID}:`)) {
+              releaseLock(key);
+            }
+          }
+        }
+      }
+    }
+  };
+};
+var index_default = OpenCodeDistributedDelegation;
+export {
+  index_default as default
+};