opencode-swarm 5.0.9 → 5.1.0

package/dist/config/constants.d.ts

@@ -9,3 +9,13 @@ export type AgentName = (typeof ALL_AGENT_NAMES)[number];
 export declare const DEFAULT_MODELS: Record<string, string>;
 export declare function isQAAgent(name: string): name is QAAgentName;
 export declare function isSubagent(name: string): boolean;
+import type { ScoringConfig } from './schema';
+export declare const DEFAULT_SCORING_CONFIG: ScoringConfig;
+/**
+ * Resolve scoring configuration by deep-merging user config with defaults.
+ * Missing scoring block → use defaults; partial weights → merge with defaults.
+ *
+ * @param userConfig - Optional user-provided scoring configuration
+ * @returns The effective scoring configuration with all defaults applied
+ */
+export declare function resolveScoringConfig(userConfig?: ScoringConfig): ScoringConfig;

package/dist/config/schema.d.ts

@@ -22,12 +22,93 @@ export declare const HooksConfigSchema: z.ZodObject<{
     agent_awareness_max_chars: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type HooksConfig = z.infer<typeof HooksConfigSchema>;
+export declare const ScoringWeightsSchema: z.ZodObject<{
+    phase: z.ZodDefault<z.ZodNumber>;
+    current_task: z.ZodDefault<z.ZodNumber>;
+    blocked_task: z.ZodDefault<z.ZodNumber>;
+    recent_failure: z.ZodDefault<z.ZodNumber>;
+    recent_success: z.ZodDefault<z.ZodNumber>;
+    evidence_presence: z.ZodDefault<z.ZodNumber>;
+    decision_recency: z.ZodDefault<z.ZodNumber>;
+    dependency_proximity: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ScoringWeights = z.infer<typeof ScoringWeightsSchema>;
+export declare const DecisionDecaySchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        linear: "linear";
+        exponential: "exponential";
+    }>>;
+    half_life_hours: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DecisionDecay = z.infer<typeof DecisionDecaySchema>;
+export declare const TokenRatiosSchema: z.ZodObject<{
+    prose: z.ZodDefault<z.ZodNumber>;
+    code: z.ZodDefault<z.ZodNumber>;
+    markdown: z.ZodDefault<z.ZodNumber>;
+    json: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TokenRatios = z.infer<typeof TokenRatiosSchema>;
+export declare const ScoringConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    max_candidates: z.ZodDefault<z.ZodNumber>;
+    weights: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodDefault<z.ZodNumber>;
+        current_task: z.ZodDefault<z.ZodNumber>;
+        blocked_task: z.ZodDefault<z.ZodNumber>;
+        recent_failure: z.ZodDefault<z.ZodNumber>;
+        recent_success: z.ZodDefault<z.ZodNumber>;
+        evidence_presence: z.ZodDefault<z.ZodNumber>;
+        decision_recency: z.ZodDefault<z.ZodNumber>;
+        dependency_proximity: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    decision_decay: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            linear: "linear";
+            exponential: "exponential";
+        }>>;
+        half_life_hours: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    token_ratios: z.ZodOptional<z.ZodObject<{
+        prose: z.ZodDefault<z.ZodNumber>;
+        code: z.ZodDefault<z.ZodNumber>;
+        markdown: z.ZodDefault<z.ZodNumber>;
+        json: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ScoringConfig = z.infer<typeof ScoringConfigSchema>;
 export declare const ContextBudgetConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     warn_threshold: z.ZodDefault<z.ZodNumber>;
     critical_threshold: z.ZodDefault<z.ZodNumber>;
     model_limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     max_injection_tokens: z.ZodDefault<z.ZodNumber>;
+    scoring: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        max_candidates: z.ZodDefault<z.ZodNumber>;
+        weights: z.ZodOptional<z.ZodObject<{
+            phase: z.ZodDefault<z.ZodNumber>;
+            current_task: z.ZodDefault<z.ZodNumber>;
+            blocked_task: z.ZodDefault<z.ZodNumber>;
+            recent_failure: z.ZodDefault<z.ZodNumber>;
+            recent_success: z.ZodDefault<z.ZodNumber>;
+            evidence_presence: z.ZodDefault<z.ZodNumber>;
+            decision_recency: z.ZodDefault<z.ZodNumber>;
+            dependency_proximity: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        decision_decay: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                linear: "linear";
+                exponential: "exponential";
+            }>>;
+            half_life_hours: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        token_ratios: z.ZodOptional<z.ZodObject<{
+            prose: z.ZodDefault<z.ZodNumber>;
+            code: z.ZodDefault<z.ZodNumber>;
+            markdown: z.ZodDefault<z.ZodNumber>;
+            json: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ContextBudgetConfig = z.infer<typeof ContextBudgetConfigSchema>;
 export declare const EvidenceConfigSchema: z.ZodObject<{
@@ -126,6 +207,33 @@ export declare const PluginConfigSchema: z.ZodObject<{
         critical_threshold: z.ZodDefault<z.ZodNumber>;
         model_limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         max_injection_tokens: z.ZodDefault<z.ZodNumber>;
+        scoring: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            max_candidates: z.ZodDefault<z.ZodNumber>;
+            weights: z.ZodOptional<z.ZodObject<{
+                phase: z.ZodDefault<z.ZodNumber>;
+                current_task: z.ZodDefault<z.ZodNumber>;
+                blocked_task: z.ZodDefault<z.ZodNumber>;
+                recent_failure: z.ZodDefault<z.ZodNumber>;
+                recent_success: z.ZodDefault<z.ZodNumber>;
+                evidence_presence: z.ZodDefault<z.ZodNumber>;
+                decision_recency: z.ZodDefault<z.ZodNumber>;
+                dependency_proximity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            decision_decay: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    linear: "linear";
+                    exponential: "exponential";
+                }>>;
+                half_life_hours: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            token_ratios: z.ZodOptional<z.ZodObject<{
+                prose: z.ZodDefault<z.ZodNumber>;
+                code: z.ZodDefault<z.ZodNumber>;
+                markdown: z.ZodDefault<z.ZodNumber>;
+                json: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     guardrails: 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/index.js

@@ -26,29 +26,6 @@ var __export = (target, all) => {
 };
 var __require = import.meta.require;
 
-// src/config/constants.ts
-var QA_AGENTS = ["reviewer", "critic"];
-var PIPELINE_AGENTS = ["explorer", "coder", "test_engineer"];
-var ORCHESTRATOR_NAME = "architect";
-var ALL_SUBAGENT_NAMES = [
-  "sme",
-  ...QA_AGENTS,
-  ...PIPELINE_AGENTS
-];
-var ALL_AGENT_NAMES = [
-  ORCHESTRATOR_NAME,
-  ...ALL_SUBAGENT_NAMES
-];
-var DEFAULT_MODELS = {
-  architect: "anthropic/claude-sonnet-4-5",
-  explorer: "google/gemini-2.0-flash",
-  coder: "anthropic/claude-sonnet-4-5",
-  test_engineer: "google/gemini-2.0-flash",
-  sme: "google/gemini-2.0-flash",
-  reviewer: "google/gemini-2.0-flash",
-  critic: "google/gemini-2.0-flash",
-  default: "google/gemini-2.0-flash"
-};
 // src/config/loader.ts
 import * as fs from "fs";
 import * as os from "os";
@@ -13603,12 +13580,40 @@ var HooksConfigSchema = exports_external.object({
   delegation_tracker: exports_external.boolean().default(false),
   agent_awareness_max_chars: exports_external.number().min(50).max(2000).default(300)
 });
+var ScoringWeightsSchema = exports_external.object({
+  phase: exports_external.number().min(0).max(5).default(1),
+  current_task: exports_external.number().min(0).max(5).default(2),
+  blocked_task: exports_external.number().min(0).max(5).default(1.5),
+  recent_failure: exports_external.number().min(0).max(5).default(2.5),
+  recent_success: exports_external.number().min(0).max(5).default(0.5),
+  evidence_presence: exports_external.number().min(0).max(5).default(1),
+  decision_recency: exports_external.number().min(0).max(5).default(1.5),
+  dependency_proximity: exports_external.number().min(0).max(5).default(1)
+});
+var DecisionDecaySchema = exports_external.object({
+  mode: exports_external.enum(["linear", "exponential"]).default("exponential"),
+  half_life_hours: exports_external.number().min(1).max(168).default(24)
+});
+var TokenRatiosSchema = exports_external.object({
+  prose: exports_external.number().min(0.1).max(1).default(0.25),
+  code: exports_external.number().min(0.1).max(1).default(0.4),
+  markdown: exports_external.number().min(0.1).max(1).default(0.3),
+  json: exports_external.number().min(0.1).max(1).default(0.35)
+});
+var ScoringConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  max_candidates: exports_external.number().min(10).max(500).default(100),
+  weights: ScoringWeightsSchema.optional(),
+  decision_decay: DecisionDecaySchema.optional(),
+  token_ratios: TokenRatiosSchema.optional()
+});
 var ContextBudgetConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   warn_threshold: exports_external.number().min(0).max(1).default(0.7),
   critical_threshold: exports_external.number().min(0).max(1).default(0.9),
   model_limits: exports_external.record(exports_external.string(), exports_external.number().min(1000)).default({ default: 128000 }),
-  max_injection_tokens: exports_external.number().min(100).max(50000).default(4000)
+  max_injection_tokens: exports_external.number().min(100).max(50000).default(4000),
+  scoring: ScoringConfigSchema.optional()
 });
 var EvidenceConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
@@ -13691,8 +13696,10 @@ function resolveGuardrailsConfig(base, agentName) {
     return base;
   }
   const baseName = stripKnownSwarmPrefix(agentName);
-  const builtIn = DEFAULT_AGENT_PROFILES[baseName];
-  const userProfile = base.profiles?.[baseName] ?? base.profiles?.[agentName];
+  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) {
     return base;
   }
@@ -13803,6 +13810,54 @@ function loadAgentPrompt(agentName) {
   }
   return result;
 }
+
+// src/config/constants.ts
+var QA_AGENTS = ["reviewer", "critic"];
+var PIPELINE_AGENTS = ["explorer", "coder", "test_engineer"];
+var ORCHESTRATOR_NAME = "architect";
+var ALL_SUBAGENT_NAMES = [
+  "sme",
+  ...QA_AGENTS,
+  ...PIPELINE_AGENTS
+];
+var ALL_AGENT_NAMES = [
+  ORCHESTRATOR_NAME,
+  ...ALL_SUBAGENT_NAMES
+];
+var DEFAULT_MODELS = {
+  architect: "anthropic/claude-sonnet-4-5",
+  explorer: "google/gemini-2.0-flash",
+  coder: "anthropic/claude-sonnet-4-5",
+  test_engineer: "google/gemini-2.0-flash",
+  sme: "google/gemini-2.0-flash",
+  reviewer: "google/gemini-2.0-flash",
+  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",
@@ -16011,7 +16066,8 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000) {
     warningIssued: false,
     warningReason: "",
     hardLimitHit: false,
-    lastSuccessTime: now
+    lastSuccessTime: now,
+    delegationActive: false
   };
   swarmState.agentSessions.set(sessionId, sessionState);
 }
@@ -16032,6 +16088,7 @@ function ensureAgentSession(sessionId, agentName) {
       session.warningReason = "";
       session.hardLimitHit = false;
       session.lastSuccessTime = now;
+      session.delegationActive = false;
     }
     session.lastToolCallTime = now;
     return session;
@@ -16267,15 +16324,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)) {
@@ -16506,7 +16569,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) {
@@ -16526,44 +16651,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);
       }
@@ -29361,6 +29575,15 @@ var OpenCodeSwarm = async (ctx) => {
     "experimental.session.compacting": compactionHook["experimental.session.compacting"],
     "command.execute.before": safeHook(commandHandler),
     "tool.execute.before": async (input, output) => {
+      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.9",
+	"version": "5.1.0",
 	"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",