opencode-swarm 5.0.10 → 5.1.1

package/dist/config/schema.d.ts

@@ -20,6 +20,8 @@ export declare const HooksConfigSchema: z.ZodObject<{
     agent_activity: z.ZodDefault<z.ZodBoolean>;
     delegation_tracker: z.ZodDefault<z.ZodBoolean>;
     agent_awareness_max_chars: z.ZodDefault<z.ZodNumber>;
+    delegation_gate: z.ZodDefault<z.ZodBoolean>;
+    delegation_max_chars: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type HooksConfig = z.infer<typeof HooksConfigSchema>;
 export declare const ScoringWeightsSchema: z.ZodObject<{
@@ -200,6 +202,8 @@ export declare const PluginConfigSchema: z.ZodObject<{
         agent_activity: z.ZodDefault<z.ZodBoolean>;
         delegation_tracker: z.ZodDefault<z.ZodBoolean>;
         agent_awareness_max_chars: z.ZodDefault<z.ZodNumber>;
+        delegation_gate: z.ZodDefault<z.ZodBoolean>;
+        delegation_max_chars: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     context_budget: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/hooks/context-scoring.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Context Scoring Utility
+ *
+ * Pure scoring/ranking helpers for context injection budget.
+ * Implements deterministic, reproducible candidate ranking based on configurable weights.
+ */
+export type ContentType = 'prose' | 'code' | 'markdown' | 'json';
+export type CandidateKind = 'phase' | 'task' | 'decision' | 'evidence' | 'agent_context';
+export interface ContextCandidate {
+    id: string;
+    kind: CandidateKind;
+    text: string;
+    tokens: number;
+    priority: number;
+    metadata: {
+        contentType: ContentType;
+        dependencyDepth?: number;
+        decisionAgeHours?: number;
+        isCurrentTask?: boolean;
+        isBlockedTask?: boolean;
+        hasFailure?: boolean;
+        hasSuccess?: boolean;
+        hasEvidence?: boolean;
+    };
+}
+export interface RankedCandidate extends ContextCandidate {
+    score: number;
+}
+export interface ScoringWeights {
+    phase: number;
+    current_task: number;
+    blocked_task: number;
+    recent_failure: number;
+    recent_success: number;
+    evidence_presence: number;
+    decision_recency: number;
+    dependency_proximity: number;
+}
+export interface DecisionDecayConfig {
+    mode: 'linear' | 'exponential';
+    half_life_hours: number;
+}
+export interface TokenRatios {
+    prose: number;
+    code: number;
+    markdown: number;
+    json: number;
+}
+export interface ScoringConfig {
+    enabled: boolean;
+    max_candidates: number;
+    weights: ScoringWeights;
+    decision_decay: DecisionDecayConfig;
+    token_ratios: TokenRatios;
+}
+/**
+ * Rank context candidates by importance score.
+ *
+ * Scoring formula:
+ * - base_score = sum of (weight * feature_flag)
+ * - For items with dependency depth: adjusted_score = base_score / (1 + depth)
+ * - For decisions with age: age_factor = 2^(-age_hours / half_life_hours), score = decision_recency * age_factor
+ *
+ * Tie-breaker: score desc → priority desc → id asc (stable sort)
+ *
+ * @param candidates - Array of context candidates
+ * @param config - Scoring configuration
+ * @returns Ranked candidates (truncated to max_candidates, original order if disabled)
+ */
+export declare function rankCandidates(candidates: ContextCandidate[], config: ScoringConfig): RankedCandidate[];

package/dist/hooks/delegation-gate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Delegation Gate Hook
+ *
+ * Warns the architect when coder delegations are too large or batched.
+ * Uses experimental.chat.messages.transform to provide non-blocking guidance.
+ */
+import type { PluginConfig } from '../config';
+interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+/**
+ * Creates the experimental.chat.messages.transform hook for delegation gating.
+ * Inspects coder delegations and warns when tasks are oversized or batched.
+ */
+export declare function createDelegationGateHook(config: PluginConfig): (input: Record<string, never>, output: {
+    messages?: MessageWithParts[];
+}) => Promise<void>;
+export {};

package/dist/hooks/index.d.ts

@@ -2,6 +2,7 @@ export { createAgentActivityHooks } from './agent-activity';
 export { createCompactionCustomizerHook } from './compaction-customizer';
 export { createContextBudgetHandler } from './context-budget';
 export { createDelegationTrackerHook } from './delegation-tracker';
+export { createDelegationGateHook } from './delegation-gate';
 export { extractCurrentPhase, extractCurrentPhaseFromPlan, extractCurrentTask, extractCurrentTaskFromPlan, extractDecisions, extractIncompleteTasks, extractIncompleteTasksFromPlan, extractPatterns, } from './extractors';
 export { createGuardrailsHooks } from './guardrails';
 export { createPipelineTrackerHook } from './pipeline-tracker';

package/dist/index.js

@@ -13578,7 +13578,9 @@ var HooksConfigSchema = exports_external.object({
   compaction: exports_external.boolean().default(true),
   agent_activity: exports_external.boolean().default(true),
   delegation_tracker: exports_external.boolean().default(false),
-  agent_awareness_max_chars: exports_external.number().min(50).max(2000).default(300)
+  agent_awareness_max_chars: exports_external.number().min(50).max(2000).default(300),
+  delegation_gate: exports_external.boolean().default(true),
+  delegation_max_chars: exports_external.number().min(500).max(20000).default(4000)
 });
 var ScoringWeightsSchema = exports_external.object({
   phase: exports_external.number().min(0).max(5).default(1),
@@ -13696,7 +13698,8 @@ function resolveGuardrailsConfig(base, agentName) {
     return base;
   }
   const baseName = stripKnownSwarmPrefix(agentName);
-  const effectiveName = baseName === "unknown" ? ORCHESTRATOR_NAME : baseName;
+  const builtInLookup = DEFAULT_AGENT_PROFILES[baseName];
+  const effectiveName = builtInLookup ? baseName : ORCHESTRATOR_NAME;
   const builtIn = DEFAULT_AGENT_PROFILES[effectiveName];
   const userProfile = base.profiles?.[effectiveName] ?? base.profiles?.[baseName] ?? base.profiles?.[agentName];
   if (!builtIn && !userProfile) {
@@ -13833,6 +13836,30 @@ var DEFAULT_MODELS = {
   critic: "google/gemini-2.0-flash",
   default: "google/gemini-2.0-flash"
 };
+var DEFAULT_SCORING_CONFIG = {
+  enabled: false,
+  max_candidates: 100,
+  weights: {
+    phase: 1,
+    current_task: 2,
+    blocked_task: 1.5,
+    recent_failure: 2.5,
+    recent_success: 0.5,
+    evidence_presence: 1,
+    decision_recency: 1.5,
+    dependency_proximity: 1
+  },
+  decision_decay: {
+    mode: "exponential",
+    half_life_hours: 24
+  },
+  token_ratios: {
+    prose: 0.25,
+    code: 0.4,
+    markdown: 0.3,
+    json: 0.35
+  }
+};
 // src/config/plan-schema.ts
 var TaskStatusSchema = exports_external.enum([
   "pending",
@@ -16041,7 +16068,8 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000) {
     warningIssued: false,
     warningReason: "",
     hardLimitHit: false,
-    lastSuccessTime: now
+    lastSuccessTime: now,
+    delegationActive: false
   };
   swarmState.agentSessions.set(sessionId, sessionState);
 }
@@ -16062,6 +16090,7 @@ function ensureAgentSession(sessionId, agentName) {
       session.warningReason = "";
       session.hardLimitHit = false;
       session.lastSuccessTime = now;
+      session.delegationActive = false;
     }
     session.lastToolCallTime = now;
     return session;
@@ -16297,15 +16326,21 @@ function createContextBudgetHandler(config2) {
 function createDelegationTrackerHook(config2) {
   return async (input, _output) => {
     if (!input.agent || input.agent === "") {
+      const session2 = swarmState.agentSessions.get(input.sessionID);
+      if (session2) {
+        session2.delegationActive = false;
+      }
       return;
     }
+    const agentName = input.agent;
     const previousAgent = swarmState.activeAgent.get(input.sessionID);
-    swarmState.activeAgent.set(input.sessionID, input.agent);
-    ensureAgentSession(input.sessionID, input.agent);
-    if (config2.hooks?.delegation_tracker === true && previousAgent && previousAgent !== input.agent) {
+    swarmState.activeAgent.set(input.sessionID, agentName);
+    const session = ensureAgentSession(input.sessionID, agentName);
+    session.delegationActive = true;
+    if (config2.hooks?.delegation_tracker === true && previousAgent && previousAgent !== agentName) {
       const entry = {
         from: previousAgent,
-        to: input.agent,
+        to: agentName,
         timestamp: Date.now()
       };
       if (!swarmState.delegationChains.has(input.sessionID)) {
@@ -16317,6 +16352,70 @@ function createDelegationTrackerHook(config2) {
     }
   };
 }
+// src/hooks/delegation-gate.ts
+function createDelegationGateHook(config2) {
+  const enabled = config2.hooks?.delegation_gate !== false;
+  const delegationMaxChars = config2.hooks?.delegation_max_chars ?? 4000;
+  if (!enabled) {
+    return async (_input, _output) => {};
+  }
+  return async (_input, output) => {
+    const messages = output?.messages;
+    if (!messages || messages.length === 0)
+      return;
+    let lastUserMessageIndex = -1;
+    for (let i = messages.length - 1;i >= 0; i--) {
+      if (messages[i]?.info?.role === "user") {
+        lastUserMessageIndex = i;
+        break;
+      }
+    }
+    if (lastUserMessageIndex === -1)
+      return;
+    const lastUserMessage = messages[lastUserMessageIndex];
+    if (!lastUserMessage?.parts)
+      return;
+    const agent = lastUserMessage.info?.agent;
+    const strippedAgent = agent ? stripKnownSwarmPrefix(agent) : undefined;
+    if (strippedAgent && strippedAgent !== "architect")
+      return;
+    const textPartIndex = lastUserMessage.parts.findIndex((p) => p?.type === "text" && p.text !== undefined);
+    if (textPartIndex === -1)
+      return;
+    const textPart = lastUserMessage.parts[textPartIndex];
+    const text = textPart.text ?? "";
+    const coderDelegationPattern = /(?:^|\n)\s*(?:\w+_)?coder\s*\n\s*TASK:/i;
+    if (!coderDelegationPattern.test(text))
+      return;
+    const warnings = [];
+    if (text.length > delegationMaxChars) {
+      warnings.push(`Delegation exceeds recommended size (${text.length} chars, limit ${delegationMaxChars}). Consider splitting into smaller tasks.`);
+    }
+    const fileMatches = text.match(/^FILE:/gm);
+    if (fileMatches && fileMatches.length > 1) {
+      warnings.push(`Multiple FILE: directives detected (${fileMatches.length}). Each coder task should target ONE file.`);
+    }
+    const taskMatches = text.match(/^TASK:/gm);
+    if (taskMatches && taskMatches.length > 1) {
+      warnings.push(`Multiple TASK: sections detected (${taskMatches.length}). Send ONE task per coder call.`);
+    }
+    const batchingPattern = /\b(?:and also|then also|additionally|as well as|along with)\b/gi;
+    const batchingMatches = text.match(batchingPattern);
+    if (batchingMatches && batchingMatches.length > 0) {
+      warnings.push("Batching language detected. Break compound objectives into separate coder calls.");
+    }
+    if (warnings.length === 0)
+      return;
+    const warningText = `[\u26A0\uFE0F DELEGATION GATE: Your coder delegation may be too complex. Issues:
+${warnings.join(`
+`)}
+Split into smaller, atomic tasks for better results.]`;
+    const originalText = textPart.text ?? "";
+    textPart.text = `${warningText}
+
+${originalText}`;
+  };
+}
 // src/hooks/guardrails.ts
 function createGuardrailsHooks(config2) {
   if (config2.enabled === false) {
@@ -16328,6 +16427,11 @@ function createGuardrailsHooks(config2) {
   }
   return {
     toolBefore: async (input, output) => {
+      const rawActiveAgent = swarmState.activeAgent.get(input.sessionID);
+      const strippedAgent = rawActiveAgent ? stripKnownSwarmPrefix(rawActiveAgent) : undefined;
+      if (strippedAgent === ORCHESTRATOR_NAME) {
+        return;
+      }
       const agentName = swarmState.activeAgent.get(input.sessionID);
       const session = ensureAgentSession(input.sessionID, agentName);
       const agentConfig = resolveGuardrailsConfig(config2, session.agentName);
@@ -16536,7 +16640,69 @@ ${originalText}`;
     })
   };
 }
+// src/hooks/context-scoring.ts
+function calculateAgeFactor(ageHours, config2) {
+  if (ageHours <= 0) {
+    return 1;
+  }
+  if (config2.mode === "exponential") {
+    return 2 ** (-ageHours / config2.half_life_hours);
+  } else {
+    const linearFactor = 1 - ageHours / (config2.half_life_hours * 2);
+    return Math.max(0, linearFactor);
+  }
+}
+function calculateBaseScore(candidate, weights, decayConfig) {
+  const { kind, metadata } = candidate;
+  const phase = kind === "phase" ? 1 : 0;
+  const currentTask = metadata.isCurrentTask ? 1 : 0;
+  const blockedTask = metadata.isBlockedTask ? 1 : 0;
+  const recentFailure = metadata.hasFailure ? 1 : 0;
+  const recentSuccess = metadata.hasSuccess ? 1 : 0;
+  const evidencePresence = metadata.hasEvidence ? 1 : 0;
+  let decisionRecency = 0;
+  if (kind === "decision" && metadata.decisionAgeHours !== undefined) {
+    decisionRecency = calculateAgeFactor(metadata.decisionAgeHours, decayConfig);
+  }
+  const dependencyProximity = 1 / (1 + (metadata.dependencyDepth ?? 0));
+  return weights.phase * phase + weights.current_task * currentTask + weights.blocked_task * blockedTask + weights.recent_failure * recentFailure + weights.recent_success * recentSuccess + weights.evidence_presence * evidencePresence + weights.decision_recency * decisionRecency + weights.dependency_proximity * dependencyProximity;
+}
+function rankCandidates(candidates, config2) {
+  if (!config2.enabled) {
+    return candidates.map((c) => ({ ...c, score: 0 }));
+  }
+  if (candidates.length === 0) {
+    return [];
+  }
+  const scored = candidates.map((candidate) => {
+    const score = calculateBaseScore(candidate, config2.weights, config2.decision_decay);
+    return { ...candidate, score };
+  });
+  scored.sort((a, b) => {
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    if (b.priority !== a.priority) {
+      return b.priority - a.priority;
+    }
+    return a.id.localeCompare(b.id);
+  });
+  return scored.slice(0, config2.max_candidates);
+}
+
 // src/hooks/system-enhancer.ts
+function estimateContentType(text) {
+  if (text.includes("```") || text.includes("function ") || text.includes("const ")) {
+    return "code";
+  }
+  if (text.startsWith("{") || text.startsWith("[")) {
+    return "json";
+  }
+  if (text.includes("#") || text.includes("*") || text.includes("- ")) {
+    return "markdown";
+  }
+  return "prose";
+}
 function createSystemEnhancerHook(config2, directory) {
   const enabled = config2.hooks?.system_enhancer !== false;
   if (!enabled) {
@@ -16556,44 +16722,133 @@ function createSystemEnhancerHook(config2, directory) {
         const maxInjectionTokens = config2.context_budget?.max_injection_tokens ?? Number.POSITIVE_INFINITY;
         let injectedTokens = 0;
         const contextContent = await readSwarmFileAsync(directory, "context.md");
-        const plan = await loadPlan(directory);
-        if (plan && plan.migration_status !== "migration_failed") {
-          const currentPhase = extractCurrentPhaseFromPlan(plan);
-          if (currentPhase) {
-            tryInject(`[SWARM CONTEXT] Current phase: ${currentPhase}`);
+        const scoringEnabled = config2.context_budget?.scoring?.enabled === true;
+        if (!scoringEnabled) {
+          const plan2 = await loadPlan(directory);
+          if (plan2 && plan2.migration_status !== "migration_failed") {
+            const currentPhase2 = extractCurrentPhaseFromPlan(plan2);
+            if (currentPhase2) {
+              tryInject(`[SWARM CONTEXT] Current phase: ${currentPhase2}`);
+            }
+            const currentTask2 = extractCurrentTaskFromPlan(plan2);
+            if (currentTask2) {
+              tryInject(`[SWARM CONTEXT] Current task: ${currentTask2}`);
+            }
+          } else {
+            const planContent = await readSwarmFileAsync(directory, "plan.md");
+            if (planContent) {
+              const currentPhase2 = extractCurrentPhase(planContent);
+              if (currentPhase2) {
+                tryInject(`[SWARM CONTEXT] Current phase: ${currentPhase2}`);
+              }
+              const currentTask2 = extractCurrentTask(planContent);
+              if (currentTask2) {
+                tryInject(`[SWARM CONTEXT] Current task: ${currentTask2}`);
+              }
+            }
           }
-          const currentTask = extractCurrentTaskFromPlan(plan);
-          if (currentTask) {
-            tryInject(`[SWARM CONTEXT] Current task: ${currentTask}`);
+          if (contextContent) {
+            const decisions = extractDecisions(contextContent, 200);
+            if (decisions) {
+              tryInject(`[SWARM CONTEXT] Key decisions: ${decisions}`);
+            }
+            if (config2.hooks?.agent_activity !== false && _input.sessionID) {
+              const activeAgent = swarmState.activeAgent.get(_input.sessionID);
+              if (activeAgent) {
+                const agentContext = extractAgentContext(contextContent, activeAgent, config2.hooks?.agent_awareness_max_chars ?? 300);
+                if (agentContext) {
+                  tryInject(`[SWARM AGENT CONTEXT] ${agentContext}`);
+                }
+              }
+            }
           }
+          return;
+        }
+        const userScoringConfig = config2.context_budget?.scoring;
+        const candidates = [];
+        let idCounter = 0;
+        const effectiveConfig = userScoringConfig?.weights ? {
+          ...DEFAULT_SCORING_CONFIG,
+          ...userScoringConfig,
+          weights: userScoringConfig.weights
+        } : DEFAULT_SCORING_CONFIG;
+        const plan = await loadPlan(directory);
+        let currentPhase = null;
+        let currentTask = null;
+        if (plan && plan.migration_status !== "migration_failed") {
+          currentPhase = extractCurrentPhaseFromPlan(plan);
+          currentTask = extractCurrentTaskFromPlan(plan);
         } else {
           const planContent = await readSwarmFileAsync(directory, "plan.md");
           if (planContent) {
-            const currentPhase = extractCurrentPhase(planContent);
-            if (currentPhase) {
-              tryInject(`[SWARM CONTEXT] Current phase: ${currentPhase}`);
-            }
-            const currentTask = extractCurrentTask(planContent);
-            if (currentTask) {
-              tryInject(`[SWARM CONTEXT] Current task: ${currentTask}`);
-            }
+            currentPhase = extractCurrentPhase(planContent);
+            currentTask = extractCurrentTask(planContent);
           }
         }
+        if (currentPhase) {
+          const text = `[SWARM CONTEXT] Current phase: ${currentPhase}`;
+          candidates.push({
+            id: `candidate-${idCounter++}`,
+            kind: "phase",
+            text,
+            tokens: estimateTokens(text),
+            priority: 1,
+            metadata: { contentType: estimateContentType(text) }
+          });
+        }
+        if (currentTask) {
+          const text = `[SWARM CONTEXT] Current task: ${currentTask}`;
+          candidates.push({
+            id: `candidate-${idCounter++}`,
+            kind: "task",
+            text,
+            tokens: estimateTokens(text),
+            priority: 2,
+            metadata: {
+              contentType: estimateContentType(text),
+              isCurrentTask: true
+            }
+          });
+        }
         if (contextContent) {
           const decisions = extractDecisions(contextContent, 200);
           if (decisions) {
-            tryInject(`[SWARM CONTEXT] Key decisions: ${decisions}`);
+            const text = `[SWARM CONTEXT] Key decisions: ${decisions}`;
+            candidates.push({
+              id: `candidate-${idCounter++}`,
+              kind: "decision",
+              text,
+              tokens: estimateTokens(text),
+              priority: 3,
+              metadata: { contentType: estimateContentType(text) }
+            });
           }
           if (config2.hooks?.agent_activity !== false && _input.sessionID) {
             const activeAgent = swarmState.activeAgent.get(_input.sessionID);
             if (activeAgent) {
               const agentContext = extractAgentContext(contextContent, activeAgent, config2.hooks?.agent_awareness_max_chars ?? 300);
               if (agentContext) {
-                tryInject(`[SWARM AGENT CONTEXT] ${agentContext}`);
+                const text = `[SWARM AGENT CONTEXT] ${agentContext}`;
+                candidates.push({
+                  id: `candidate-${idCounter++}`,
+                  kind: "agent_context",
+                  text,
+                  tokens: estimateTokens(text),
+                  priority: 4,
+                  metadata: { contentType: estimateContentType(text) }
+                });
               }
             }
           }
         }
+        const ranked = rankCandidates(candidates, effectiveConfig);
+        for (const candidate of ranked) {
+          if (injectedTokens + candidate.tokens > maxInjectionTokens) {
+            continue;
+          }
+          output.system.push(candidate.text);
+          injectedTokens += candidate.tokens;
+        }
       } catch (error49) {
         warn("System enhancer failed:", error49);
       }
@@ -29338,6 +29593,7 @@ var OpenCodeSwarm = async (ctx) => {
   const commandHandler = createSwarmCommandHandler(ctx.directory, Object.fromEntries(agentDefinitions.map((agent) => [agent.name, agent])));
   const activityHooks = createAgentActivityHooks(config3, ctx.directory);
   const delegationHandler = createDelegationTrackerHook(config3);
+  const delegationGateHandler = createDelegationGateHook(config3);
   const guardrailsConfig = GuardrailsConfigSchema.parse(config3.guardrails ?? {});
   const guardrailsHooks = createGuardrailsHooks(guardrailsConfig);
   log("Plugin initialized", {
@@ -29385,7 +29641,8 @@ var OpenCodeSwarm = async (ctx) => {
     "experimental.chat.messages.transform": composeHandlers(...[
       pipelineHook["experimental.chat.messages.transform"],
       contextBudgetHandler,
-      guardrailsHooks.messagesTransform
+      guardrailsHooks.messagesTransform,
+      delegationGateHandler
     ].filter((fn) => Boolean(fn))),
     "experimental.chat.system.transform": systemEnhancerHook["experimental.chat.system.transform"],
     "experimental.session.compacting": compactionHook["experimental.session.compacting"],
@@ -29394,6 +29651,12 @@ var OpenCodeSwarm = async (ctx) => {
       if (!swarmState.activeAgent.has(input.sessionID)) {
         swarmState.activeAgent.set(input.sessionID, ORCHESTRATOR_NAME);
       }
+      const session = swarmState.agentSessions.get(input.sessionID);
+      const activeAgent = swarmState.activeAgent.get(input.sessionID);
+      if (session && activeAgent && activeAgent !== ORCHESTRATOR_NAME && session.delegationActive === false) {
+        swarmState.activeAgent.set(input.sessionID, ORCHESTRATOR_NAME);
+        ensureAgentSession(input.sessionID, ORCHESTRATOR_NAME);
+      }
       await guardrailsHooks.toolBefore(input, output);
       await safeHook(activityHooks.toolBefore)(input, output);
     },

package/dist/state.d.ts

@@ -61,6 +61,8 @@ export interface AgentSessionState {
     hardLimitHit: boolean;
     /** Timestamp of most recent SUCCESSFUL tool call (for idle timeout) */
     lastSuccessTime: number;
+    /** Whether active delegation is in progress for this session */
+    delegationActive: boolean;
 }
 /**
  * Singleton state object for sharing data across hooks

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "5.0.10",
+	"version": "5.1.1",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",