opencode-swarm 7.21.5 → 7.22.1

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.21.5",
+    version: "7.22.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",
@@ -17455,6 +17455,14 @@ var init_schema = __esm(() => {
       const trimmed = v.trim();
       return trimmed === "" ? undefined : trimmed;
     }),
+    auto_select_architect: exports_external.union([exports_external.boolean(), exports_external.string()]).optional().transform((v) => {
+      if (v === undefined)
+        return;
+      if (typeof v === "boolean")
+        return v;
+      const trimmed = v.trim();
+      return trimmed === "" ? false : trimmed;
+    }),
     swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
     max_iterations: exports_external.number().min(1).max(10).default(5),
     pipeline: PipelineConfigSchema.optional(),
@@ -21015,9 +21023,10 @@ var init_guardrails = __esm(() => {
 function clearPendingCoderScope() {
   pendingCoderScopeByTaskId.clear();
 }
-var pendingCoderScopeByTaskId;
+var pendingCoderScopeByTaskId, ACTIVE_PARALLEL_TASK_STATES;
 var init_delegation_gate = __esm(() => {
   init_schema();
+  init_manager();
   init_state();
   init_telemetry();
   init_logger();
@@ -21026,6 +21035,12 @@ var init_delegation_gate = __esm(() => {
   init_normalize_tool_name();
   init_utils2();
   pendingCoderScopeByTaskId = new Map;
+  ACTIVE_PARALLEL_TASK_STATES = new Set([
+    "coder_delegated",
+    "pre_check_passed",
+    "reviewer_run",
+    "tests_run"
+  ]);
 });
 
 // src/state/agent-run-context.ts

package/dist/config/schema.d.ts

@@ -828,6 +828,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
     default_agent: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    auto_select_architect: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>, z.ZodTransform<string | boolean | undefined, string | boolean | undefined>>;
     swarms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.21.5",
+    version: "7.22.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",
@@ -15668,6 +15668,14 @@ var init_schema = __esm(() => {
       const trimmed = v.trim();
       return trimmed === "" ? undefined : trimmed;
     }),
+    auto_select_architect: exports_external.union([exports_external.boolean(), exports_external.string()]).optional().transform((v) => {
+      if (v === undefined)
+        return;
+      if (typeof v === "boolean")
+        return v;
+      const trimmed = v.trim();
+      return trimmed === "" ? false : trimmed;
+    }),
     swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
     max_iterations: exports_external.number().min(1).max(10).default(5),
     pipeline: PipelineConfigSchema.optional(),
@@ -26766,6 +26774,70 @@ function extractPlanTaskId(text) {
 function getSeedTaskId(session) {
   return session.currentTaskId ?? session.lastCoderDelegationTaskId;
 }
+function isTaskCompletedForParallelGuidance(task) {
+  const status = task.status ?? "pending";
+  return status === "completed" || status === "closed";
+}
+async function buildParallelExecutionGuidance(directory, sessionID, session) {
+  if (!directory)
+    return null;
+  const plan = await loadPlanJsonOnly(directory);
+  if (!plan) {
+    return null;
+  }
+  const profile = plan.execution_profile;
+  const enabled = profile?.parallelization_enabled === true;
+  const maxConcurrent = profile?.max_concurrent_tasks ?? 1;
+  if (!enabled || maxConcurrent <= 1)
+    return null;
+  if (hasActiveLeanTurbo(sessionID)) {
+    return "[NEXT] Lean Turbo is active; use lean_turbo_run_phase and Lean Turbo lane guidance instead of standard execution-profile slot filling.";
+  }
+  const currentPhase = plan.current_phase !== undefined ? plan.phases.find((phase) => phase.id === plan.current_phase) : plan.phases.find((phase) => !isParallelGuidancePhaseComplete(phase));
+  if (!currentPhase)
+    return null;
+  const tasks = currentPhase.tasks;
+  if (tasks.length === 0)
+    return null;
+  const allTasks = plan.phases.flatMap((phase) => phase.tasks);
+  const completed = new Set;
+  for (const task of allTasks) {
+    const taskId = task.id;
+    if (isTaskCompletedForParallelGuidance(task))
+      completed.add(taskId);
+    if (getTaskState(session, taskId) === "complete")
+      completed.add(taskId);
+  }
+  const occupied = new Set;
+  for (const task of allTasks) {
+    const taskId = task.id;
+    if (task.status === "in_progress")
+      occupied.add(taskId);
+    const state = getTaskState(session, taskId);
+    if (ACTIVE_PARALLEL_TASK_STATES.has(state))
+      occupied.add(taskId);
+  }
+  const availableSlots = Math.max(0, maxConcurrent - occupied.size);
+  if (availableSlots <= 0) {
+    return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${maxConcurrent}; all standard execution slots are occupied. Continue current active task gates before starting more coder work.`;
+  }
+  const eligible = tasks.filter((task) => {
+    const taskId = task.id;
+    const status = task.status ?? "pending";
+    if (status !== "pending")
+      return false;
+    if (occupied.has(taskId))
+      return false;
+    return task.depends.every((dep) => completed.has(dep));
+  }).map((task) => task.id).slice(0, availableSlots);
+  if (eligible.length === 0) {
+    return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${maxConcurrent}; no dependency-ready pending tasks are available for a new coder slot. Continue the current task/gate.`;
+  }
+  return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${maxConcurrent}; ${occupied.size} slot(s) occupied. Eligible now: ${eligible.join(", ")}. [NEXT] dispatch up to ${availableSlots} eligible coder task(s) before waiting; preserve ONE task per coder call and call declare_scope for each task.`;
+}
+function isParallelGuidancePhaseComplete(phase) {
+  return phase.status === "complete" || phase.status === "completed" || phase.status === "closed";
+}
 async function getEvidenceTaskId(session, directory) {
   const primary = session.currentTaskId ?? session.lastCoderDelegationTaskId;
   if (primary)
@@ -27271,15 +27343,16 @@ ${trimComment}${after}`;
           if (!/^[a-zA-Z0-9_-]{1,128}$/.test(deliberationSessionID)) {} else {
             const deliberationSession = ensureAgentSession(deliberationSessionID);
             const lastGate = deliberationSession.lastGateOutcome;
+            const parallelGuidance = await buildParallelExecutionGuidance(directory, deliberationSessionID, deliberationSession);
             let guidance;
             if (lastGate?.taskId) {
               const gateResult = lastGate.passed ? "PASSED" : "FAILED";
               const sanitizedGate = lastGate.gate.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\[ \]/g, "()").replace(/\[/g, "(").replace(/\]/g, ")").replace(/[\r\n]/g, " ").slice(0, 64);
               const sanitizedTaskId = lastGate.taskId.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\[/g, "(").replace(/\]/g, ")").replace(/[\r\n]/g, " ").slice(0, 32);
               guidance = `[Last gate: ${sanitizedGate} ${gateResult} for task ${sanitizedTaskId}]
-[NEXT] Execute the next gate for the current task.`;
+${parallelGuidance ?? "[NEXT] Execute the next gate for the current task."}`;
             } else {
-              guidance = "[NEXT] Begin the first plan task and run gates sequentially.";
+              guidance = parallelGuidance ?? "[NEXT] Begin the first plan task and run gates sequentially.";
             }
             const systemMsgIdx = messages.findIndex((m) => m && m.info?.role === "system");
             const insertIdx = systemMsgIdx >= 0 ? systemMsgIdx + 1 : 0;
@@ -27372,9 +27445,10 @@ ${warningLines.join(`
     toolAfter
   };
 }
-var pendingCoderScopeByTaskId;
+var pendingCoderScopeByTaskId, ACTIVE_PARALLEL_TASK_STATES;
 var init_delegation_gate = __esm(() => {
   init_schema();
+  init_manager();
   init_state();
   init_telemetry();
   init_logger();
@@ -27383,6 +27457,12 @@ var init_delegation_gate = __esm(() => {
   init_normalize_tool_name();
   init_utils2();
   pendingCoderScopeByTaskId = new Map;
+  ACTIVE_PARALLEL_TASK_STATES = new Set([
+    "coder_delegated",
+    "pre_check_passed",
+    "reviewer_run",
+    "tests_run"
+  ]);
 });
 
 // src/state/agent-run-context.ts
@@ -62845,6 +62925,8 @@ If a tool modifies a file, it is a CODER tool. Delegate.
   - Rationale: declare_scope persists the allowed set to disk (.swarm/scopes/scope-\${taskId}.json) so it survives cross-process delegation. Without a call, the coder process reads an empty scope and every Edit/Write is denied.
 <!-- BEHAVIORAL_GUIDANCE_END -->
 2. ONE agent per message. Send, STOP, wait for response.
+   Exception: Stage B reviewer/test_engineer gate agents for the SAME completed coder task may be dispatched together before waiting when both gates are required.
+   This exception NEVER applies to coder delegations. Preserve ONE task per coder call.
 3. ONE task per {{AGENT_PREFIX}}coder call. Never batch.
 3a. PRE-DELEGATION SCOPE CALL (required): BEFORE every {{AGENT_PREFIX}}coder delegation, you MUST call \`declare_scope\` with { taskId, files } listing the exact file(s) this task will modify (including generated/lockfile paths). No \`declare_scope\` call → no coder delegation. See Rule 1a.
 <!-- BEHAVIORAL_GUIDANCE_START -->
@@ -62985,7 +63067,7 @@ VERIFICATION PROTOCOL: After the coder reports DONE, and before running Stage B
 The reviewer's verdict MUST include a REUSE_RE_VERIFICATION field — do NOT accept an APPROVED verdict without it. Validate the field value against context: if the coder's EXPORTS_ADDED was non-empty, REUSE_RE_VERIFICATION must be VERIFIED or DUPLICATION_DETECTED (not SKIPPED). If EXPORTS_ADDED was "none", REUSE_RE_VERIFICATION must be SKIPPED.
 Stage B runs by default for TIER 1-3 classifications. Stage A passing does not satisfy Stage B.
 Stage B is where logic errors, security flaws, edge cases, and behavioral bugs are caught.
-You MUST delegate to each Stage B agent and wait for their response.
+You MUST delegate to each required Stage B agent. For the standard reviewer + test_engineer pair, dispatch both before waiting so Stage B actually runs in parallel.
 
 Stage B (reviewer + test_engineer) **always runs per-task** regardless of council mode — it is never replaced, never omitted, never deferred. When \`council_mode\` is enabled in the QA gate profile, a **phase-level** council review is additionally required before calling \`phase_complete\`: dispatch all 5 council members, collect their verdicts, call \`submit_phase_council_verdicts\`, then call \`phase_complete\` (Gate 5 validates the resulting \`phase-council.json\` evidence). Stage A (\`pre_check_batch\`) still runs as the pre-review gate for each task.
 
@@ -105323,11 +105405,65 @@ async function initializeOpenCodeSwarm(ctx) {
       swarm_command: createSwarmCommandTool(agentDefinitionMap)
     },
     config: async (opencodeConfig) => {
+      if (!opencodeConfig.agent || typeof opencodeConfig.agent !== "object") {
+        opencodeConfig.agent = {};
+      }
       if (!opencodeConfig.agent) {
         opencodeConfig.agent = { ...agents };
       } else {
         Object.assign(opencodeConfig.agent, agents);
       }
+      const autoSelect = config3?.auto_select_architect;
+      if (autoSelect) {
+        const hasArchitect = Object.keys(agents).some((name2) => stripKnownSwarmPrefix(name2) === "architect");
+        if (hasArchitect) {
+          for (const builtin of ["build", "plan"]) {
+            const existing = opencodeConfig.agent?.[builtin];
+            if (existing && typeof existing === "object" && existing.disable === true) {
+              continue;
+            }
+            opencodeConfig.agent[builtin] = {
+              ...existing && typeof existing === "object" ? existing : {},
+              disable: true
+            };
+          }
+          if (autoSelect === true) {
+            const primaryArchitects = Object.entries(agents).filter(([name2, cfg]) => stripKnownSwarmPrefix(name2) === "architect" && cfg.mode === "primary");
+            if (primaryArchitects.length > 1) {
+              const names = primaryArchitects.map(([n]) => n).join(", ");
+              addDeferredWarning(`[swarm] auto_select_architect is true but ${primaryArchitects.length} architect agents are primary (${names}). Consider setting auto_select_architect to a specific agent name.`);
+            }
+          }
+          if (typeof autoSelect === "string" && autoSelect !== "") {
+            const targetName = autoSelect;
+            const targetIsArchitect = Object.hasOwn(agents, targetName) && stripKnownSwarmPrefix(targetName) === "architect";
+            if (targetIsArchitect) {
+              for (const [name2, cfg] of Object.entries(agents)) {
+                if (stripKnownSwarmPrefix(name2) === "architect" && name2 !== targetName) {
+                  if (opencodeConfig.agent && typeof opencodeConfig.agent === "object") {
+                    opencodeConfig.agent[name2] = {
+                      ...cfg && typeof cfg === "object" ? cfg : {},
+                      mode: "subagent"
+                    };
+                  }
+                }
+              }
+              if (opencodeConfig.agent && typeof opencodeConfig.agent === "object") {
+                const targetExisting = opencodeConfig.agent[targetName];
+                opencodeConfig.agent[targetName] = {
+                  ...targetExisting && typeof targetExisting === "object" ? targetExisting : {},
+                  ...agents[targetName] && typeof agents[targetName] === "object" ? agents[targetName] : {},
+                  mode: "primary"
+                };
+              }
+            } else {
+              addDeferredWarning(`[swarm] auto_select_architect is set to "${targetName}" but that is not a known architect agent. No architect demotion applied.`);
+            }
+          }
+        } else {
+          addDeferredWarning("[swarm] auto_select_architect is enabled but no architect agents were found in the generated set. The option has no effect.");
+        }
+      }
       opencodeConfig.command = {
         ...opencodeConfig.command || {},
         swarm: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.21.5",
+	"version": "7.22.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",