opencode-swarm 7.60.0 → 7.61.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.60.0",
+    version: "7.61.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",
@@ -577,11 +577,11 @@ var init_tool_metadata = __esm(() => {
       ]
     },
     get_qa_gate_profile: {
-      description: "retrieve the QA gate profile for the current plan: gates (reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, council_general_review, drift_check, final_council), lock state, and profile hash. Read-only.",
+      description: "retrieve the QA gate profile for the current plan: gates (reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, phase_council, drift_check, final_council), lock state, and profile hash. Read-only.",
       agents: ["architect"]
     },
     set_qa_gates: {
-      description: "configure the QA gate profile for the current plan. Architect-only. Ratchet-tighter only — rejected once the profile is locked after critic approval. Supports: reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, council_general_review, drift_check, final_council.",
+      description: "configure the QA gate profile for the current plan. Architect-only. Ratchet-tighter only — rejected once the profile is locked after critic approval. Supports: reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, phase_council, drift_check, final_council.",
       agents: ["architect"]
     },
     web_search: {
@@ -15906,7 +15906,7 @@ var init_schema = __esm(() => {
     requireAllMembers: exports_external.boolean().default(false).describe("When true, submit_council_verdicts rejects if fewer than 5 member verdicts are provided. Equivalent to minimumMembers: 5."),
     minimumMembers: exports_external.number().int().min(1).max(5).default(3).describe("Minimum distinct council member verdicts required for synthesis. Default 3. Set to 1 to disable quorum enforcement. requireAllMembers: true overrides this to 5 (stricter constraint wins)."),
     escalateOnMaxRounds: exports_external.string().optional().describe("Optional webhook URL or handler name invoked when maxRounds is reached without APPROVE. Declared for forward compatibility; no behavior is implemented yet."),
-    phaseConcernsAllowComplete: exports_external.boolean().default(true).describe("When true, a phase-level council CONCERNS verdict does NOT block phase completion — the advisory notes are logged as warnings and the phase proceeds. When false, CONCERNS blocks like REJECT. Default: true (CONCERNS is advisory)."),
+    phaseConcernsAllowComplete: exports_external.boolean().default(true).describe("When true, a phase-level council CONCERNS verdict with only MEDIUM/LOW findings does NOT block phase completion — the advisory notes are logged as warnings and the phase proceeds. When false, CONCERNS blocks like REJECT. Note: HIGH/CRITICAL findings from CONCERNS members are always promoted to requiredFixes and block at the tool level regardless of this setting. Default: true."),
     general: GeneralCouncilConfigSchema.optional()
   }).strict();
   ParallelizationConfigSchema = exports_external.object({
@@ -21783,11 +21783,26 @@ import { createHash as createHash3 } from "node:crypto";
 function rowToProfile(row) {
   let parsed = {};
   try {
-    parsed = JSON.parse(row.gates);
+    const maybeGates = JSON.parse(row.gates);
+    if (maybeGates && typeof maybeGates === "object" && !Array.isArray(maybeGates)) {
+      parsed = maybeGates;
+    }
   } catch {
     parsed = {};
   }
-  const gates = { ...DEFAULT_QA_GATES, ...parsed };
+  const raw = parsed;
+  if (raw.council_mode === true && raw.phase_council === undefined) {
+    parsed.phase_council = true;
+    parsed.council_mode = false;
+  }
+  const knownKeys = new Set(Object.keys(DEFAULT_QA_GATES));
+  const filteredParsed = {};
+  for (const key of Object.keys(parsed)) {
+    if (knownKeys.has(key)) {
+      filteredParsed[key] = parsed[key];
+    }
+  }
+  const gates = { ...DEFAULT_QA_GATES, ...filteredParsed };
   return {
     id: row.id,
     plan_id: row.plan_id,
@@ -21910,7 +21925,7 @@ var init_qa_gate_profile = __esm(() => {
     hallucination_guard: false,
     sast_enabled: true,
     mutation_test: false,
-    council_general_review: false,
+    phase_council: false,
     drift_check: true,
     final_council: false
   };
@@ -41939,7 +41954,8 @@ function createDelegationGateHook(config2, directory) {
     if (!session)
       return;
     const normalized = normalizeToolName(input.tool);
-    const councilActive = await isCouncilGateActive(directory, config2.council);
+    const { qaGateSessionOverrides } = ensureAgentSession(input.sessionID);
+    const councilActive = await isCouncilGateActive(directory, config2.council, qaGateSessionOverrides ?? {});
     if (normalized === "update_task_status") {
       const directArgs = input.args;
       const storedArgs = getStoredInputArgs(input.callID);
@@ -42049,86 +42065,88 @@ function createDelegationGateHook(config2, directory) {
           hasReviewer = true;
         if (targetAgent === "test_engineer")
           hasTestEngineer = true;
-        const stageBParallelEnabled = true;
-        if (stageBParallelEnabled) {
-          if ((targetAgent === "reviewer" || targetAgent === "test_engineer") && session.taskWorkflowStates) {
-            const stageBEligibleStates = [
-              "coder_delegated",
-              "pre_check_passed",
-              "reviewer_run"
-            ];
-            for (const [taskId, state] of session.taskWorkflowStates) {
-              if (!stageBEligibleStates.includes(state))
-                continue;
-              const eligibleState = state;
-              recordStageBCompletion(session, taskId, targetAgent);
-              if (hasBothStageBCompletions(session, taskId)) {
-                try {
-                  if (eligibleState === "coder_delegated" || eligibleState === "pre_check_passed") {
-                    advanceTaskState(session, taskId, "reviewer_run", {
-                      telemetrySessionId: input.sessionID
-                    });
-                  }
-                  advanceTaskState(session, taskId, "tests_run", {
-                    telemetrySessionId: input.sessionID
-                  });
-                } catch (err2) {
-                  warn(`[delegation-gate] toolAfter stage-b-parallel: could not advance ${taskId} (${eligibleState}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
-                }
-              } else {
-                try {
-                  if (targetAgent === "reviewer" && (eligibleState === "coder_delegated" || eligibleState === "pre_check_passed")) {
-                    advanceTaskState(session, taskId, "reviewer_run", {
-                      telemetrySessionId: input.sessionID
-                    });
-                  } else if (targetAgent === "test_engineer" && eligibleState === "reviewer_run") {
-                    advanceTaskState(session, taskId, "tests_run", {
-                      telemetrySessionId: input.sessionID
-                    });
-                  }
-                } catch (err2) {
-                  warn(`[delegation-gate] toolAfter stage-b-parallel intermediate: could not advance ${taskId} (${eligibleState}) after ${targetAgent}: ${err2 instanceof Error ? err2.message : String(err2)}`);
-                }
-              }
-            }
-            const seedTaskId = getSeedTaskId(session);
-            if (seedTaskId) {
-              for (const [, otherSession] of swarmState.agentSessions) {
-                if (otherSession === session)
-                  continue;
-                if (!otherSession.taskWorkflowStates)
-                  continue;
-                if (!otherSession.taskWorkflowStates.has(seedTaskId)) {
-                  otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
-                }
-                const seedState = otherSession.taskWorkflowStates.get(seedTaskId);
-                if (!seedState || !stageBEligibleStates.includes(seedState)) {
+        if (!councilActive) {
+          const stageBParallelEnabled = true;
+          if (stageBParallelEnabled) {
+            if ((targetAgent === "reviewer" || targetAgent === "test_engineer") && session.taskWorkflowStates) {
+              const stageBEligibleStates = [
+                "coder_delegated",
+                "pre_check_passed",
+                "reviewer_run"
+              ];
+              for (const [taskId, state] of session.taskWorkflowStates) {
+                if (!stageBEligibleStates.includes(state))
                   continue;
-                }
-                const seedEligibleState = seedState;
-                recordStageBCompletion(otherSession, seedTaskId, targetAgent);
-                if (hasBothStageBCompletions(otherSession, seedTaskId)) {
+                const eligibleState = state;
+                recordStageBCompletion(session, taskId, targetAgent);
+                if (hasBothStageBCompletions(session, taskId)) {
                   try {
-                    if (seedEligibleState === "coder_delegated" || seedEligibleState === "pre_check_passed") {
-                      advanceTaskState(otherSession, seedTaskId, "reviewer_run", { emitTelemetry: false });
+                    if (eligibleState === "coder_delegated" || eligibleState === "pre_check_passed") {
+                      advanceTaskState(session, taskId, "reviewer_run", {
+                        telemetrySessionId: input.sessionID
+                      });
                     }
-                    advanceTaskState(otherSession, seedTaskId, "tests_run", {
-                      emitTelemetry: false
+                    advanceTaskState(session, taskId, "tests_run", {
+                      telemetrySessionId: input.sessionID
                     });
                   } catch (err2) {
-                    warn(`[delegation-gate] toolAfter cross-session stage-b-parallel: could not advance ${seedTaskId} (${seedEligibleState}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    warn(`[delegation-gate] toolAfter stage-b-parallel: could not advance ${taskId} (${eligibleState}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 } else {
                   try {
-                    if (targetAgent === "reviewer" && (seedEligibleState === "coder_delegated" || seedEligibleState === "pre_check_passed")) {
-                      advanceTaskState(otherSession, seedTaskId, "reviewer_run", { emitTelemetry: false });
-                    } else if (targetAgent === "test_engineer" && seedEligibleState === "reviewer_run") {
+                    if (targetAgent === "reviewer" && (eligibleState === "coder_delegated" || eligibleState === "pre_check_passed")) {
+                      advanceTaskState(session, taskId, "reviewer_run", {
+                        telemetrySessionId: input.sessionID
+                      });
+                    } else if (targetAgent === "test_engineer" && eligibleState === "reviewer_run") {
+                      advanceTaskState(session, taskId, "tests_run", {
+                        telemetrySessionId: input.sessionID
+                      });
+                    }
+                  } catch (err2) {
+                    warn(`[delegation-gate] toolAfter stage-b-parallel intermediate: could not advance ${taskId} (${eligibleState}) after ${targetAgent}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  }
+                }
+              }
+              const seedTaskId = getSeedTaskId(session);
+              if (seedTaskId) {
+                for (const [, otherSession] of swarmState.agentSessions) {
+                  if (otherSession === session)
+                    continue;
+                  if (!otherSession.taskWorkflowStates)
+                    continue;
+                  if (!otherSession.taskWorkflowStates.has(seedTaskId)) {
+                    otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
+                  }
+                  const seedState = otherSession.taskWorkflowStates.get(seedTaskId);
+                  if (!seedState || !stageBEligibleStates.includes(seedState)) {
+                    continue;
+                  }
+                  const seedEligibleState = seedState;
+                  recordStageBCompletion(otherSession, seedTaskId, targetAgent);
+                  if (hasBothStageBCompletions(otherSession, seedTaskId)) {
+                    try {
+                      if (seedEligibleState === "coder_delegated" || seedEligibleState === "pre_check_passed") {
+                        advanceTaskState(otherSession, seedTaskId, "reviewer_run", { emitTelemetry: false });
+                      }
                       advanceTaskState(otherSession, seedTaskId, "tests_run", {
                         emitTelemetry: false
                       });
+                    } catch (err2) {
+                      warn(`[delegation-gate] toolAfter cross-session stage-b-parallel: could not advance ${seedTaskId} (${seedEligibleState}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    }
+                  } else {
+                    try {
+                      if (targetAgent === "reviewer" && (seedEligibleState === "coder_delegated" || seedEligibleState === "pre_check_passed")) {
+                        advanceTaskState(otherSession, seedTaskId, "reviewer_run", { emitTelemetry: false });
+                      } else if (targetAgent === "test_engineer" && seedEligibleState === "reviewer_run") {
+                        advanceTaskState(otherSession, seedTaskId, "tests_run", {
+                          emitTelemetry: false
+                        });
+                      }
+                    } catch (err2) {
+                      warn(`[delegation-gate] toolAfter cross-session stage-b-parallel intermediate: could not advance ${seedTaskId} (${seedEligibleState}) after ${targetAgent}: ${err2 instanceof Error ? err2.message : String(err2)}`);
                     }
-                  } catch (err2) {
-                    warn(`[delegation-gate] toolAfter cross-session stage-b-parallel intermediate: could not advance ${seedTaskId} (${seedEligibleState}) after ${targetAgent}: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -42167,7 +42185,7 @@ function createDelegationGateHook(config2, directory) {
       if (storedArgs !== undefined) {
         deleteStoredInputArgs(input.callID);
       }
-      if (!subagentType || !hasReviewer) {
+      if (!subagentType || !hasReviewer || councilActive) {
         const delegationChain = swarmState.delegationChains.get(input.sessionID);
         if (delegationChain && delegationChain.length > 0) {
           let lastCoderIndex = -1;
@@ -42191,69 +42209,71 @@ function createDelegationGateHook(config2, directory) {
             session.qaSkipCount = 0;
             session.qaSkipTaskIds = [];
           }
-          if (lastCoderIndex !== -1 && hasReviewer && session.taskWorkflowStates) {
-            for (const [taskId, state] of session.taskWorkflowStates) {
-              if (state === "coder_delegated" || state === "pre_check_passed") {
-                try {
-                  advanceTaskState(session, taskId, "reviewer_run");
-                } catch (err2) {
-                  warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) → reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
-                }
-              }
-            }
-          }
-          if (lastCoderIndex !== -1 && hasReviewer && hasTestEngineer && session.taskWorkflowStates) {
-            for (const [taskId, state] of session.taskWorkflowStates) {
-              if (state === "reviewer_run") {
-                try {
-                  advanceTaskState(session, taskId, "tests_run");
-                } catch (err2) {
-                  warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
-                }
-              }
-            }
-          }
-          if (lastCoderIndex !== -1 && hasReviewer) {
-            for (const [, otherSession] of swarmState.agentSessions) {
-              if (otherSession === session)
-                continue;
-              if (!otherSession.taskWorkflowStates)
-                continue;
-              const seedTaskId = getSeedTaskId(session);
-              if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
-                otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
-              }
-              for (const [taskId, state] of otherSession.taskWorkflowStates) {
+          if (!councilActive) {
+            if (lastCoderIndex !== -1 && hasReviewer && session.taskWorkflowStates) {
+              for (const [taskId, state] of session.taskWorkflowStates) {
                 if (state === "coder_delegated" || state === "pre_check_passed") {
                   try {
-                    advanceTaskState(otherSession, taskId, "reviewer_run", {
-                      emitTelemetry: false
-                    });
+                    advanceTaskState(session, taskId, "reviewer_run");
                   } catch (err2) {
-                    warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) → reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) → reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
             }
-          }
-          if (lastCoderIndex !== -1 && hasReviewer && hasTestEngineer) {
-            for (const [, otherSession] of swarmState.agentSessions) {
-              if (otherSession === session)
-                continue;
-              if (!otherSession.taskWorkflowStates)
-                continue;
-              const seedTaskId = getSeedTaskId(session);
-              if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
-                otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
-              }
-              for (const [taskId, state] of otherSession.taskWorkflowStates) {
+            if (lastCoderIndex !== -1 && hasReviewer && hasTestEngineer && session.taskWorkflowStates) {
+              for (const [taskId, state] of session.taskWorkflowStates) {
                 if (state === "reviewer_run") {
                   try {
-                    advanceTaskState(otherSession, taskId, "tests_run", {
-                      emitTelemetry: false
-                    });
+                    advanceTaskState(session, taskId, "tests_run");
                   } catch (err2) {
-                    warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  }
+                }
+              }
+            }
+            if (lastCoderIndex !== -1 && hasReviewer) {
+              for (const [, otherSession] of swarmState.agentSessions) {
+                if (otherSession === session)
+                  continue;
+                if (!otherSession.taskWorkflowStates)
+                  continue;
+                const seedTaskId = getSeedTaskId(session);
+                if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
+                  otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
+                }
+                for (const [taskId, state] of otherSession.taskWorkflowStates) {
+                  if (state === "coder_delegated" || state === "pre_check_passed") {
+                    try {
+                      advanceTaskState(otherSession, taskId, "reviewer_run", {
+                        emitTelemetry: false
+                      });
+                    } catch (err2) {
+                      warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) → reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    }
+                  }
+                }
+              }
+            }
+            if (lastCoderIndex !== -1 && hasReviewer && hasTestEngineer) {
+              for (const [, otherSession] of swarmState.agentSessions) {
+                if (otherSession === session)
+                  continue;
+                if (!otherSession.taskWorkflowStates)
+                  continue;
+                const seedTaskId = getSeedTaskId(session);
+                if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
+                  otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
+                }
+                for (const [taskId, state] of otherSession.taskWorkflowStates) {
+                  if (state === "reviewer_run") {
+                    try {
+                      advanceTaskState(otherSession, taskId, "tests_run", {
+                        emitTelemetry: false
+                      });
+                    } catch (err2) {
+                      warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) → tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    }
                   }
                 }
               }
@@ -43077,7 +43097,7 @@ function hasBothStageBCompletions(session, taskId) {
     return false;
   return completions.has("reviewer") && completions.has("test_engineer");
 }
-async function isCouncilGateActive(directory, council) {
+async function isCouncilGateActive(directory, council, sessionOverrides = {}) {
   const enabled = council?.enabled === true;
   let plan = null;
   try {
@@ -43103,13 +43123,13 @@ async function isCouncilGateActive(directory, council) {
   if (!profile) {
     return false;
   }
-  const councilMode = profile.gates.council_mode === true;
+  const councilMode = getEffectiveGates(profile, sessionOverrides).council_mode === true;
   if (enabled && councilMode) {
     return true;
   }
   if (enabled !== councilMode && !_councilDisagreementWarned.has(planId)) {
     _councilDisagreementWarned.add(planId);
-    warn(`[delegation-gate] Council mode mismatch for plan ${planId}: ` + `pluginConfig.council.enabled=${enabled}, QaGates.council_mode=${councilMode}. ` + "Falling back to Stage B (non-council) advancement.");
+    warn(`[delegation-gate] Council mode mismatch for plan ${planId}: ` + `pluginConfig.council.enabled=${enabled}, QaGates.council_mode=${councilMode}. ` + "Falling back to Stage B (non-council) per-task advancement.");
   }
   return false;
 }
@@ -80755,7 +80775,7 @@ var init_qa_gates = __esm(() => {
     "hallucination_guard",
     "sast_enabled",
     "mutation_test",
-    "council_general_review",
+    "phase_council",
     "drift_check",
     "final_council"
   ];
@@ -84128,7 +84148,7 @@ Subcommands:
       handler: (ctx) => handleQaGatesCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "View or modify QA gate profile for the current plan [enable|override <gate>...]",
       args: "[show|enable|override] <gate>...",
-      details: "show: display spec-level, session-override, and effective QA gates for the current plan. enable: persist gate(s) into the locked-once profile (architect; rejected after critic approval lock). override: session-only ratchet-tighter enable. Valid gates: reviewer, test_engineer, council_mode, sme_enabled, critic_pre_plan, hallucination_guard, sast_enabled, mutation_test, council_general_review, drift_check.",
+      details: "show: display spec-level, session-override, and effective QA gates for the current plan. enable: persist gate(s) into the locked-once profile (architect; rejected after critic approval lock). override: session-only ratchet-tighter enable. Valid gates: reviewer, test_engineer, council_mode, sme_enabled, critic_pre_plan, hallucination_guard, sast_enabled, mutation_test, phase_council, drift_check, final_council.",
       category: "config"
     },
     promote: {
@@ -84371,24 +84391,87 @@ Do NOT dispatch the supervisor yourself as a reviewer of code — it is summary-
 function buildCouncilWorkflow(council) {
   if (council?.enabled !== true)
     return "";
-  return `## COUNCIL WORKFLOW (submit_phase_council_verdicts)
+  return `## COUNCIL WORKFLOW
+
+ANTI-CONFUSION: Do NOT confuse the three council modes:
+(1) \`council_mode\` — per-task full council replacing Stage B.
+(2) \`phase_council\` — phase-level holistic review at \`phase_complete\`.
+(3) \`final_council\` — project-level final review after all phases.
+None of these use the General Council (3-agent advisory). The General Council is an early workflow option gated by \`council.general.enabled\`, not a QA gate.
+
+## A. PER-TASK COUNCIL (when \`council_mode\` is ON)
+
+When \`council_mode\` is enabled in the QA gate profile, Stage B (reviewer + test_engineer) is **replaced** by the full 5-member council (critic, reviewer, sme, test_engineer, explorer) per task. Stage A (\`pre_check_batch\`) still runs as the pre-review gate.
+
+### PREREQUISITES
+- \`declare_council_criteria\` must be called for each task before council dispatch.
+
+### MANDATORY SEQUENCE — never skip or reorder
+
+#### STEP 1 — DISPATCH all 5 council members in parallel (task-scoped)
+After Stage A passes for a task, in a SINGLE message, dispatch \`critic\`, \`reviewer\`, \`sme\`, \`test_engineer\`, and \`explorer\` as parallel Agent tasks. Each member receives task-scoped context:
+- \`critic\`        — task diff + task spec + approved-plan baseline (via \`get_approved_plan\`) + spec-intent drift analysis
+- \`reviewer\`      — task semantic diff summary + blast radius across changed files
+- \`sme\`           — task domain context + knowledge base entries relevant to the task
+- \`test_engineer\` — changed test files for the task + coverage delta + known mutation gaps
+- \`explorer\`      — task diff + original task intent + prior slop findings
+                    (hunts for lazy implementations, hallucinated APIs, cargo-cult patterns,
+                     spec drift, lazy abstractions)
+
+Wait for ALL dispatched agents to return their verdict objects before proceeding.
+
+#### STEP 2 — COLLECT verdicts
+Read each agent's response and extract their \`CouncilMemberVerdict\` object.
+Each member must return: \`agent\`, \`verdict\` (APPROVE|CONCERNS|REJECT),
+\`confidence\` (0.0–1.0), \`findings[]\`, \`criteriaAssessed[]\`, \`criteriaUnmet[]\`,
+\`durationMs\`.
+
+Do NOT fabricate, infer, or substitute a verdict. If an agent did not return
+a valid verdict object, re-dispatch that agent.
+
+#### STEP 3 — CALL submit_council_verdicts (the per-task tool, NOT submit_phase_council_verdicts)
+ONLY after collecting real verdicts from all dispatched agents, call
+\`submit_council_verdicts\` with the collected verdicts. The per-task council
+verdict replaces the Stage B gate — APPROVE advances the task, REJECT blocks it.
+
+#### STEP 4 — ACT on the verdict
+- **APPROVE**: Task passes. Proceed to the next task.
+  If \`advisoryFindingsCount > 0\`, deliver \`unifiedFeedbackMd\` as a single
+  non-blocking advisory note before proceeding.
+- **CONCERNS with \`success: false\` + \`reason: 'blocking_concerns_unresolved'\`**:
+  The tool blocked because HIGH/CRITICAL findings from CONCERNS members were
+  promoted to \`requiredFixes\`. No evidence was written. Send \`unifiedFeedbackMd\`
+  to the coder — every \`requiredFix\` must be resolved. Increment \`roundNumber\`
+  and re-convene council after fixes. This is tool-enforced: you cannot bypass it.
+- **CONCERNS with \`success: true\`**: Only MEDIUM/LOW advisory findings remain.
+  Task passes — surface \`unifiedFeedbackMd\` as a non-blocking note.
+- **REJECT**: Block task advancement. Send \`unifiedFeedbackMd\` to the coder
+  with the BLOCKING flag. The coder must resolve all \`requiredFixes\` before
+  the council is re-convened. Maximum \`council.maxRounds\` rounds (default 3).
+  If \`roundNumber >= maxRounds\` and verdict is still REJECT, surface
+  \`unifiedFeedbackMd\` to the user and HALT — do NOT auto-advance.
+
+### ANTI-PATTERNS — per-task council bypass violations
+- ✗ Calling \`submit_council_verdicts\` without first dispatching all 5 members.
+- ✗ Passing verdicts inferred or fabricated rather than received from dispatched agents.
+- ✗ Claiming "Council APPROVED" when \`membersAbsent\` is non-empty.
+- ✗ Falling back to Stage B (reviewer + test_engineer only) when \`council_mode\` is ON — the full council replaces Stage B.
+- ✗ Skipping \`declare_council_criteria\` before dispatching council members.
+- ✗ Using \`submit_phase_council_verdicts\` for per-task verdicts — use \`submit_council_verdicts\`.
+
+## B. PHASE COUNCIL (when \`phase_council\` is ON)
 
 CRITICAL: \`submit_phase_council_verdicts\` does NOT run council members.
 It synthesizes verdicts that you must collect BEFORE calling it.
 
-When \`council.enabled\` is true and \`council_mode\` is enabled in the QA gate
-profile, a phase-level council review is required before calling \`phase_complete\`.
-Stage B (reviewer + test_engineer) ALWAYS runs per-task as normal.
-Stage B always runs per-task — council is an ADDITIONAL verification layer at PHASE LEVEL, never a replacement for Stage B.
+When \`phase_council\` is enabled in the QA gate profile, a phase-level council review is required before calling \`phase_complete\`. This is additive to whichever per-task mechanism is active — Stage B (reviewer + test_engineer) runs per task by default, or the full 5-member per-task council if \`council_mode\` is ON.
 
-### WHEN TO RUN COUNCIL
+### WHEN TO RUN PHASE COUNCIL
 After ALL tasks in the current phase have been marked \`completed\` and their
-Stage B gates have passed, and BEFORE calling \`phase_complete\`, convene the
+per-task gates have passed, and BEFORE calling \`phase_complete\`, convene the
 phase council for a Phase Dossier Assembly — a holistic review of cross-cutting concerns,
 behavioral cohesion, and the full body of work completed in the phase.
 
-## PHASE COUNCIL
-
 ### MANDATORY SEQUENCE — never skip or reorder
 
 #### STEP 1 — DISPATCH all 5 council members in parallel (phase-scoped)
@@ -84437,10 +84520,13 @@ and re-call \`submit_phase_council_verdicts\`.
 - **APPROVE**: Call \`phase_complete\`. Gate 5 will pass.
   If \`advisoryFindingsCount > 0\`, deliver \`unifiedFeedbackMd\` as a single
   non-blocking advisory note to the team before proceeding.
-- **CONCERNS**: Evaluate severity. Minor concerns → call \`phase_complete\` and
-  surface \`unifiedFeedbackMd\` as a non-blocking note. Significant concerns →
-  send \`unifiedFeedbackMd\` to the coder as ONE coherent document for resolution
-  before calling \`phase_complete\`. Increment \`roundNumber\` on re-council.
+- **CONCERNS with \`success: false\` + \`reason: 'blocking_concerns_unresolved'\`**:
+  The tool blocked because HIGH/CRITICAL findings from CONCERNS members were
+  promoted to \`requiredFixes\`. No evidence was written. Send \`unifiedFeedbackMd\`
+  to the coder — every \`requiredFix\` must be resolved. Increment \`roundNumber\`
+  and re-convene council after fixes. This is tool-enforced: you cannot bypass it.
+- **CONCERNS with \`success: true\`**: Only MEDIUM/LOW advisory findings remain.
+  Call \`phase_complete\` and surface \`unifiedFeedbackMd\` as a non-blocking note.
 - **REJECT**: Block advancement. Send \`unifiedFeedbackMd\` to the coder
   with the BLOCKING flag. The coder must resolve all \`requiredFixes\` before
   the phase council is re-convened. Maximum \`council.maxRounds\` rounds (default 3).
@@ -84451,10 +84537,11 @@ and re-call \`submit_phase_council_verdicts\`.
 - ✗ Calling \`submit_phase_council_verdicts\` without first dispatching all 5 members.
 - ✗ Passing verdicts inferred or fabricated rather than received from dispatched agents.
 - ✗ Claiming "Council APPROVED" when \`membersAbsent\` is non-empty.
-- ✗ Omitting per-task review gates (reviewer + test_engineer) because council mode is on — these gates are mandatory regardless.
+- ✗ Skipping per-task gates because phase council will catch issues — per-task gates are mandatory regardless.
 - ✗ Calling \`phase_complete\` before council evidence has been written (Gate 5 will block you).
 - ✗ Treating a prior phase's council verdict as valid for a new phase.
 - ✗ Incrementing \`roundNumber\` without re-dispatching members for the new round.
+- ✗ Using \`submit_council_verdicts\` for phase verdicts — use \`submit_phase_council_verdicts\`.
 
 ### ROUND 2 DELIBERATION
 If round 1 produces REJECT or CONCERNS requiring re-work, every prior-round
@@ -84497,16 +84584,25 @@ Present the eleven gates with their defaults (DEFAULT_QA_GATES) as a single user
 - sme_enabled (default: ON) — SME consultation during planning/clarification
 - critic_pre_plan (default: ON) — critic review before plan finalization
 - sast_enabled (default: ON) — static security scanning
-- council_mode (default: OFF) — multi-member council gate (recommended for high-impact architecture, public APIs, schema/data mutation, security-sensitive code)
+- council_mode (default: OFF) — replaces per-task Stage B (reviewer + test_engineer) with the full 5-member council (critic, reviewer, sme, test_engineer, explorer). When enabled, Stage A still runs, but after Stage A passes, all 5 council members review the task instead of just reviewer + test_engineer. Requires council.enabled: true in config. (recommended for high-impact architecture, public APIs, schema/data mutation, security-sensitive code)
 - hallucination_guard (default: OFF) — when enabled, mandatory per-phase API/signature/claim/citation verification via critic_hallucination_verifier at PHASE-WRAP; phase_complete will REJECT phase completion unless .swarm/evidence/{phase}/hallucination-guard.json exists with an APPROVED verdict (recommended for claim-heavy or research-heavy work)
 - mutation_test (default: OFF) — when enabled, runs mutation testing on source files touched this phase via generate_mutants + mutation_test + write_mutation_evidence at PHASE-WRAP; FAIL verdict blocks phase_complete; WARN is non-blocking (recommended for projects with coverage gaps or safety-critical code)
-- council_general_review (default: OFF) — when enabled, MODE: SPECIFY runs convene_general_council on the draft spec before the critic-gate; the architect runs a curated web_search pass, dispatches council_generalist / council_skeptic / council_domain_expert in parallel with a shared RESEARCH CONTEXT block, deliberates on disagreements, and synthesizes the result directly into the spec (recommended for novel architecture, unclear best practices, or high-risk design decisions). Requires council.general.enabled: true and a configured search API key in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project .opencode/opencode-swarm.json overrides.
+- phase_council (default: OFF) — when enabled, a full 5-member council (critic, reviewer, sme, test_engineer, explorer) reviews all work completed in a phase holistically at phase_complete time. This is additive to whichever per-task mechanism is active — Stage B (reviewer + test_engineer) by default, or the full 5-member per-task council if council_mode is ON. Requires council.enabled: true in config.
 - drift_check (default: ON) — when enabled, mandatory per-phase drift verification via critic_drift_verifier at PHASE-WRAP; compares implemented changes against spec.md intent; hard-blocks phase_complete when spec.md exists and drift evidence is missing or REJECTED; advisory-only when no spec.md exists (recommended for all projects with a specification)
-- final_council (default: OFF) - when enabled, after all phases complete the architect dispatches the same five phase-council members (\`critic\`, \`reviewer\`, \`sme\`, \`test_engineer\`, \`explorer\`) at project scope, collects \`CouncilMemberVerdict\` objects, and calls \`write_final_council_evidence\`. This is not General Council mode and does not require \`council.general.enabled\`.
+- final_council (default: OFF) — when enabled, the full 5-member council (NOT the General Council) reviews the entire project after all phases complete. The architect dispatches the same five council members (\`critic\`, \`reviewer\`, \`sme\`, \`test_engineer\`, \`explorer\`) at project scope, collects \`CouncilMemberVerdict\` objects, and calls \`write_final_council_evidence\`. This is not General Council mode and does not require \`council.general.enabled\`.
+
+Present all three items together in a single message. One message, defaults pre-stated. Wait for the user's answer to all three:
 
-One question, one message, defaults pre-stated. Wait for the user's answer.
+**1. QA Gates** — accept defaults or customize (the eleven gates listed above).
 
-If the user answered the gate question, immediately follow up with ONE more question: "How many coders should run in parallel? (default: 1, range: 1-4)" — if the user says a number > 1, also write a \`## Pending Parallelization Config\` section to \`.swarm/context.md\` alongside the gate selection:
+**2. Parallel Coders** — "How many coders should run in parallel? (default: 1, range: 1-4)"
+
+**3. Commit Frequency** — "Commit frequency for completed tasks? (default: phase-level only; optional per-task checkpoint commit after each task completion)"
+
+Wait for the user to answer all three in a single reply. Then apply:
+
+- For gates: record the user's gate selections.
+- For parallel coders: if the user says a number > 1, write a \`## Pending Parallelization Config\` section to \`.swarm/context.md\` alongside the gate selection:
 \`\`\`
 ## Pending Parallelization Config
 - parallelization_enabled: true
@@ -84517,9 +84613,7 @@ If the user answered the gate question, immediately follow up with ONE more ques
 \`\`\`
 If the user accepts the default (1), skip writing this section entirely — serial execution is the default and needs no config.
 
-After asking the parallelization question (regardless of whether the user chose serial or parallel), immediately follow up with ONE more question: "Commit frequency for completed tasks? (default: phase-level only; optional per-task checkpoint commit after each task completion)".
-
-If the user chooses per-task commits, write this section to \`.swarm/context.md\`:
+- For commit frequency: if the user chooses per-task commits, write this section to \`.swarm/context.md\`:
 \`\`\`
 ## Task Completion Commit Policy
 - commit_after_each_completed_task: true
@@ -84971,7 +85065,7 @@ TIER 3 — CRITICAL
   Pipeline: Full Stage A. Stage B = {{AGENT_PREFIX}}reviewer×2 + {{AGENT_PREFIX}}test_engineer×2.
   Rationale: Security paths need adversarial review.
 
-Council mode is additive — Stage B always runs per-task in both modes. The council runs holistically at phase end via \`submit_phase_council_verdicts\` before calling \`phase_complete\`. Council is supplemental; Stage B is mandatory in all modes.
+When \`council_mode\` is enabled, Stage B (reviewer + test_engineer) is replaced by the full 5-member council per task. When \`phase_council\` is enabled, a phase-level council review is additionally required before calling \`phase_complete\`.
 
 CLASSIFICATION RULES:
 - Multi-tier → use HIGHEST tier.
@@ -84998,7 +85092,7 @@ Stage B runs by default for TIER 1-3 classifications. Stage A passing does not s
 Stage B is where logic errors, security flaws, edge cases, and behavioral bugs are caught.
 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.
+When \`council_mode\` is enabled, Stage B (reviewer + test_engineer) is **replaced** by the full 5-member council (critic, reviewer, sme, test_engineer, explorer) per task. Stage A (\`pre_check_batch\`) still runs as the pre-review gate. When \`phase_council\` is enabled, a phase-level council review is additionally required before calling \`phase_complete\`: dispatch all 5 council members with phase-scoped context, collect their verdicts, call \`submit_phase_council_verdicts\`, then call \`phase_complete\` (Gate 5 validates the resulting \`phase-council.json\` evidence).
 
 A task is complete ONLY when BOTH stages pass.
 
@@ -85375,6 +85469,7 @@ HARD CONSTRAINTS:
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
 - Treat brainstorm output as discovery material until the loaded skill transitions to SPECIFY or PLAN.
+- When council.general.enabled is true, the brainstorm skill offers the user a General Council advisory input option before spec writing. This is NOT a QA gate — it's an early workflow option. The convene_general_council tool must be available when council.general.enabled is true.
 <!-- BEHAVIORAL_GUIDANCE_END -->
 
 ### MODE: SPECIFY
@@ -85391,6 +85486,7 @@ HARD CONSTRAINTS:
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
 - Follow the loaded skill's spec creation, clarification, and transition rules.
+- General Council advisory input is available via the /swarm council command at any time. It is NOT offered as a SPECIFY workflow step — it moved to BRAINSTORM Phase 1b as an early option before spec writing.
 <!-- BEHAVIORAL_GUIDANCE_END -->
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
@@ -98130,7 +98226,7 @@ DELEGATION RULES:
 ${complianceHeader}
 - Reviewer delegation is MANDATORY for every coder task.
 - pre_check_batch is NOT a substitute for reviewer.
-- Stage A (tools) + Stage B (agents) = BOTH required.
+- Stage A (automated tools) + Stage B/Council (agent review) = BOTH required.
 ${phaseNumber !== null && phaseNumber >= 4 ? `
 ⚠️ You are in Phase ${phaseNumber}. Compliance degrades with time. Do not skip reviewer or test_engineer.` : ""}
 </swarm_reminder>`;
@@ -111833,16 +111929,17 @@ function synthesizeCouncilVerdicts(taskId, swarmId, verdicts, criteria, roundNum
   const unresolvedConflicts = detectConflicts2(verdicts);
   const rejectingSet = new Set(rejectingMembers);
   const vetoFindings = verdicts.filter((v) => rejectingSet.has(v.agent)).flatMap((v) => v.findings);
-  const requiredFixes = vetoFindings.filter((f) => f.severity === "HIGH" || f.severity === "MEDIUM");
+  const requiredFixes = vetoFindings.filter((f) => f.severity === "CRITICAL" || f.severity === "HIGH" || f.severity === "MEDIUM");
   const advisoryFindings = [
     ...vetoFindings.filter((f) => f.severity === "LOW"),
     ...verdicts.filter((v) => !rejectingSet.has(v.agent)).flatMap((v) => v.findings)
   ];
+  const blockingConcernsCount = promoteBlockingConcerns(verdicts, rejectingSet, requiredFixes, advisoryFindings);
   const allAssessedIds = new Set(verdicts.flatMap((v) => v.criteriaAssessed));
   const allUnmetIds = new Set(verdicts.flatMap((v) => v.criteriaUnmet));
   const mandatoryIds = new Set((criteria?.criteria ?? []).filter((c) => c.mandatory).map((c) => c.id));
   const allCriteriaMet = [...mandatoryIds].every((id) => allAssessedIds.has(id) && !allUnmetIds.has(id));
-  const unifiedFeedbackMd = buildUnifiedFeedback(taskId, overallVerdict, rejectingMembers, requiredFixes, advisoryFindings, unresolvedConflicts, roundNumber, cfg.maxRounds);
+  const unifiedFeedbackMd = buildUnifiedFeedback(taskId, overallVerdict, rejectingMembers, requiredFixes, advisoryFindings, unresolvedConflicts, roundNumber, cfg.maxRounds, blockingConcernsCount);
   return {
     taskId,
     swarmId,
@@ -111857,9 +111954,24 @@ function synthesizeCouncilVerdicts(taskId, swarmId, verdicts, criteria, roundNum
     roundNumber,
     allCriteriaMet,
     quorumSize,
+    blockingConcernsCount,
     ...verdicts.length === 0 && { emptyVerdictsWarning: true }
   };
 }
+function promoteBlockingConcerns(verdicts, rejectingSet, requiredFixes, advisoryFindings) {
+  const concernsFindings = verdicts.filter((v) => v.verdict === "CONCERNS" && !rejectingSet.has(v.agent)).flatMap((v) => v.findings);
+  const blocking = concernsFindings.filter((f) => f.severity === "CRITICAL" || f.severity === "HIGH");
+  if (blocking.length === 0)
+    return 0;
+  requiredFixes.push(...blocking);
+  const blockingSet = new Set(blocking);
+  for (let i2 = advisoryFindings.length - 1;i2 >= 0; i2--) {
+    if (blockingSet.has(advisoryFindings[i2])) {
+      advisoryFindings.splice(i2, 1);
+    }
+  }
+  return blocking.length;
+}
 function detectConflicts2(verdicts) {
   const conflicts = [];
   const locationMap = new Map;
@@ -111889,7 +112001,7 @@ function detectConflicts2(verdicts) {
   }
   return conflicts;
 }
-function buildUnifiedFeedback(taskId, verdict, vetoedBy, requiredFixes, advisoryFindings, conflicts, roundNumber, maxRounds) {
+function buildUnifiedFeedback(taskId, verdict, vetoedBy, requiredFixes, advisoryFindings, conflicts, roundNumber, maxRounds, blockingConcernsCount = 0) {
   const lines = [
     `## Work Complete Council — Round ${roundNumber}/${maxRounds}`,
     `**Task:** ${taskId}  **Overall verdict:** ${verdict}`,
@@ -111899,6 +112011,10 @@ function buildUnifiedFeedback(taskId, verdict, vetoedBy, requiredFixes, advisory
     lines.push(`> ⛔ **BLOCKED** by: ${vetoedBy.join(", ")}`);
     lines.push("");
   }
+  if (blockingConcernsCount > 0) {
+    lines.push(`> ⚠️ **BLOCKING CONCERNS**: ${blockingConcernsCount} HIGH/CRITICAL finding(s) from CONCERNS members require investigation and resolution before advancement.`);
+    lines.push("");
+  }
   if (requiredFixes.length > 0) {
     lines.push("### Required Fixes (must resolve before re-submission)");
     for (const f of requiredFixes) {
@@ -111946,11 +112062,12 @@ function synthesizePhaseCouncilAdvisory(phaseNumber, phaseSummary, verdicts, rou
   const unresolvedConflicts = detectConflicts2(verdicts);
   const rejectingSet = new Set(rejectingMembers);
   const vetoFindings = verdicts.filter((v) => rejectingSet.has(v.agent)).flatMap((v) => v.findings);
-  const requiredFixes = vetoFindings.filter((f) => f.severity === "HIGH" || f.severity === "MEDIUM");
+  const requiredFixes = vetoFindings.filter((f) => f.severity === "CRITICAL" || f.severity === "HIGH" || f.severity === "MEDIUM");
   const advisoryFindings = [
     ...vetoFindings.filter((f) => f.severity === "LOW"),
     ...verdicts.filter((v) => !rejectingSet.has(v.agent)).flatMap((v) => v.findings)
   ];
+  const blockingConcernsCount = promoteBlockingConcerns(verdicts, rejectingSet, requiredFixes, advisoryFindings);
   const advisoryNotes = [];
   if (advisoryFindings.length > 0) {
     advisoryNotes.push(`Phase ${phaseNumber} council found ${advisoryFindings.length} advisory finding(s). Review before proceeding to next phase.`);
@@ -111960,7 +112077,7 @@ function synthesizePhaseCouncilAdvisory(phaseNumber, phaseSummary, verdicts, rou
   }
   const allUnmetIds = new Set(verdicts.flatMap((v) => v.criteriaUnmet));
   const allCriteriaMet = allUnmetIds.size === 0 && verdicts.length > 0;
-  const unifiedFeedbackMd = buildPhaseCouncilFeedback(phaseNumber, phaseSummary, overallVerdict, rejectingMembers, requiredFixes, advisoryFindings, unresolvedConflicts, roundNumber, cfg.maxRounds);
+  const unifiedFeedbackMd = buildPhaseCouncilFeedback(phaseNumber, phaseSummary, overallVerdict, rejectingMembers, requiredFixes, advisoryFindings, unresolvedConflicts, roundNumber, cfg.maxRounds, blockingConcernsCount);
   const evidencePath = `.swarm/evidence/${phaseNumber}/phase-council.json`;
   return {
     phaseNumber,
@@ -111977,11 +112094,12 @@ function synthesizePhaseCouncilAdvisory(phaseNumber, phaseSummary, verdicts, rou
     roundNumber,
     allCriteriaMet,
     quorumSize,
+    blockingConcernsCount,
     evidencePath,
     phaseSummary
   };
 }
-function buildPhaseCouncilFeedback(phaseNumber, phaseSummary, verdict, vetoedBy, requiredFixes, advisoryFindings, conflicts, roundNumber, maxRounds) {
+function buildPhaseCouncilFeedback(phaseNumber, phaseSummary, verdict, vetoedBy, requiredFixes, advisoryFindings, conflicts, roundNumber, maxRounds, blockingConcernsCount = 0) {
   const lines = [
     `## Phase Council Review — Round ${roundNumber}/${maxRounds}`,
     `**Phase:** ${phaseNumber}  **Overall verdict:** ${verdict}`,
@@ -111995,6 +112113,10 @@ function buildPhaseCouncilFeedback(phaseNumber, phaseSummary, verdict, vetoedBy,
     lines.push(`> ⛔ **BLOCKED** by: ${vetoedBy.join(", ")}`);
     lines.push("");
   }
+  if (blockingConcernsCount > 0) {
+    lines.push(`> ⚠️ **BLOCKING CONCERNS**: ${blockingConcernsCount} HIGH/CRITICAL finding(s) from CONCERNS members require investigation and resolution before phase completion.`);
+    lines.push("");
+  }
   if (requiredFixes.length > 0) {
     lines.push("### Required Fixes (must resolve before re-submission)");
     for (const f of requiredFixes) {
@@ -112041,11 +112163,12 @@ function synthesizeFinalCouncilAdvisory(projectSummary, verdicts, roundNumber, c
   const unresolvedConflicts = detectConflicts2(verdicts);
   const rejectingSet = new Set(rejectingMembers);
   const vetoFindings = verdicts.filter((v) => rejectingSet.has(v.agent)).flatMap((v) => v.findings);
-  const requiredFixes = vetoFindings.filter((f) => f.severity === "HIGH" || f.severity === "MEDIUM");
+  const requiredFixes = vetoFindings.filter((f) => f.severity === "CRITICAL" || f.severity === "HIGH" || f.severity === "MEDIUM");
   const advisoryFindings = [
     ...vetoFindings.filter((f) => f.severity === "LOW"),
     ...verdicts.filter((v) => !rejectingSet.has(v.agent)).flatMap((v) => v.findings)
   ];
+  const blockingConcernsCount = promoteBlockingConcerns(verdicts, rejectingSet, requiredFixes, advisoryFindings);
   const advisoryNotes = [];
   if (advisoryFindings.length > 0) {
     advisoryNotes.push(`Final council found ${advisoryFindings.length} advisory finding(s). Review before project close.`);
@@ -112055,7 +112178,7 @@ function synthesizeFinalCouncilAdvisory(projectSummary, verdicts, roundNumber, c
   }
   const allUnmetIds = new Set(verdicts.flatMap((v) => v.criteriaUnmet));
   const allCriteriaMet = allUnmetIds.size === 0 && verdicts.length > 0;
-  const unifiedFeedbackMd = buildFinalCouncilFeedback(projectSummary, overallVerdict, rejectingMembers, requiredFixes, advisoryFindings, unresolvedConflicts, roundNumber, cfg.maxRounds);
+  const unifiedFeedbackMd = buildFinalCouncilFeedback(projectSummary, overallVerdict, rejectingMembers, requiredFixes, advisoryFindings, unresolvedConflicts, roundNumber, cfg.maxRounds, blockingConcernsCount);
   return {
     scope: "project",
     timestamp,
@@ -112071,10 +112194,11 @@ function synthesizeFinalCouncilAdvisory(projectSummary, verdicts, roundNumber, c
     allCriteriaMet,
     quorumSize,
     evidencePath: ".swarm/evidence/final-council.json",
+    blockingConcernsCount,
     projectSummary
   };
 }
-function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFixes, advisoryFindings, conflicts, roundNumber, maxRounds) {
+function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFixes, advisoryFindings, conflicts, roundNumber, maxRounds, blockingConcernsCount = 0) {
   const lines = [
     `## Final Council Review - Round ${roundNumber}/${maxRounds}`,
     `**Scope:** completed project  **Overall verdict:** ${verdict}`,
@@ -112084,6 +112208,10 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
     lines.push(`**Project Summary:** ${projectSummary}`);
     lines.push("");
   }
+  if (blockingConcernsCount > 0) {
+    lines.push(`> ⚠️ **BLOCKING CONCERNS**: ${blockingConcernsCount} HIGH/CRITICAL finding(s) from CONCERNS members require investigation and resolution before project close.`);
+    lines.push("");
+  }
   if (vetoedBy.length > 0) {
     lines.push(`> BLOCKED: project close is blocked by ${vetoedBy.join(", ")}`);
     lines.push("");
@@ -112162,7 +112290,7 @@ init_state();
 init_create_tool();
 init_resolve_working_directory();
 var FindingSchema = exports_external.object({
-  severity: exports_external.enum(["HIGH", "MEDIUM", "LOW"]),
+  severity: exports_external.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]),
   category: exports_external.string().min(1),
   location: exports_external.string(),
   detail: exports_external.string(),
@@ -112203,7 +112331,7 @@ var submit_council_verdicts = createSwarmTool({
       verdictRound: exports_external.number().int().min(1).max(10).optional(),
       confidence: exports_external.number().min(0).max(1),
       findings: exports_external.array(exports_external.object({
-        severity: exports_external.enum(["HIGH", "MEDIUM", "LOW"]),
+        severity: exports_external.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]),
         category: exports_external.string().min(1),
         location: exports_external.string(),
         detail: exports_external.string(),
@@ -112306,6 +112434,17 @@ var submit_council_verdicts = createSwarmTool({
         session.pendingCouncilRequirements.set(nextRoundKey, new Set(dissenters));
       }
     }
+    if (synthesis.overallVerdict === "CONCERNS" && synthesis.blockingConcernsCount > 0) {
+      return JSON.stringify({
+        success: false,
+        reason: "blocking_concerns_unresolved",
+        overallVerdict: synthesis.overallVerdict,
+        blockingConcernsCount: synthesis.blockingConcernsCount,
+        requiredFixes: synthesis.requiredFixes,
+        unifiedFeedbackMd: synthesis.unifiedFeedbackMd,
+        message: `Council returned CONCERNS with ${synthesis.blockingConcernsCount} HIGH/CRITICAL finding(s) promoted to requiredFixes. These must be resolved before the task can advance. Do NOT write evidence or proceed — address every requiredFix and resubmit.`
+      }, null, 2);
+    }
     await writeCouncilEvidence(workingDir, synthesis);
     try {
       if (sessionID) {
@@ -119886,7 +120025,7 @@ async function runPhaseCouncilGate(ctx) {
         const session = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
         const overrides = session?.qaGateSessionOverrides ?? {};
         const effective = getEffectiveGates(profile, overrides);
-        if (effective.council_mode === true) {
+        if (effective.phase_council === true && pluginConfig.council?.enabled === true) {
           councilModeEnabled = true;
           const pcPath = path148.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
           let pcVerdictFound = false;
@@ -119990,7 +120129,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
               blocked: true,
               reason: "PHASE_COUNCIL_REQUIRED",
               phase_council_required: true,
-              message: `Phase ${phase} cannot be completed: council_mode is enabled and phase council evidence not found at .swarm/evidence/${phase}/phase-council.json. Convene a phase-level council (dispatch 5 members, collect verdicts, call submit_phase_council_verdicts) before completing the phase.`,
+              message: `Phase ${phase} cannot be completed: phase_council is enabled and phase council evidence not found at .swarm/evidence/${phase}/phase-council.json. Convene a phase-level council (dispatch 5 members, collect verdicts, call submit_phase_council_verdicts) before completing the phase.`,
               agentsDispatched,
               agentsMissing: [],
               warnings: [
@@ -120046,7 +120185,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
       return {
         blocked: true,
         reason: "PHASE_COUNCIL_ERROR",
-        message: `Phase ${phase} cannot be completed: phase council gate encountered an error when council_mode was enabled. Error: ${String(pcError)}`,
+        message: `Phase ${phase} cannot be completed: phase council gate encountered an error when phase_council was enabled. Error: ${String(pcError)}`,
         agentsDispatched,
         agentsMissing: [],
         warnings: [`PHASE_COUNCIL_ERROR: ${String(pcError)}`]
@@ -128056,7 +128195,7 @@ async function executeSetQaGates(args2, directory) {
     "hallucination_guard",
     "sast_enabled",
     "mutation_test",
-    "council_general_review",
+    "phase_council",
     "drift_check",
     "final_council"
   ]) {
@@ -128098,13 +128237,13 @@ var set_qa_gates = createSwarmTool({
   args: {
     reviewer: exports_external.boolean().optional().describe("Enable the reviewer gate (true) — cannot be disabled."),
     test_engineer: exports_external.boolean().optional().describe("Enable the test_engineer gate (true) — cannot be disabled once on."),
-    council_mode: exports_external.boolean().optional().describe("Enable council mode (multi-SME consensus on high-risk phases)."),
+    council_mode: exports_external.boolean().optional().describe("Enable council mode — replaces per-task Stage B (reviewer + test_engineer) with the full 5-member council (critic, reviewer, sme, test_engineer, explorer) per task."),
     sme_enabled: exports_external.boolean().optional().describe("Enable SME consultation."),
     critic_pre_plan: exports_external.boolean().optional().describe("Enable critic_pre_plan review before plan approval."),
     hallucination_guard: exports_external.boolean().optional().describe("Enable hallucination_guard checks on plan and implementation claims."),
     sast_enabled: exports_external.boolean().optional().describe("Enable SAST scanning as a required QA gate."),
     mutation_test: exports_external.boolean().optional().describe("Enable the mutation-testing gate (default: off). Requires mutation " + "tests to achieve a passing kill rate before phase completion; " + "WARN verdict allows advancement, FAIL blocks."),
-    council_general_review: exports_external.boolean().optional().describe("Enable the council_general_review gate (default: off). When on, " + "MODE: SPECIFY runs convene_general_council on the draft spec " + "before the critic-gate, folding multi-model deliberation into " + "the spec. Requires council.general.enabled and a search API key " + "in the resolved config: global ~/.config/opencode/opencode-swarm.json, " + "then project .opencode/opencode-swarm.json overrides."),
+    phase_council: exports_external.boolean().optional().describe("Enable the phase_council gate (default: off). When on, a full " + "5-member council (critic, reviewer, sme, test_engineer, explorer) " + "reviews all work completed in a phase holistically at phase_complete " + "time. Requires council.enabled: true in config."),
     drift_check: exports_external.boolean().optional().describe("Enable drift verification gate (default: on). Blocks phase_complete " + "until drift-verifier.json has an approved verdict. When disabled, " + "drift verification is skipped entirely."),
     final_council: exports_external.boolean().optional().describe("Enable the final_council gate (default: off). When on, " + "after all phases complete the architect dispatches critic, reviewer, " + "sme, test_engineer, and explorer with project-scoped context, " + "collects their CouncilMemberVerdict objects, and calls " + "write_final_council_evidence. This is not General Council mode " + "and does not require council.general.enabled."),
     project_type: exports_external.string().optional().describe('Project type label (e.g. "ts", "python"). Only applied when the profile is being created for the first time.')
@@ -128363,7 +128502,7 @@ var VerdictSchema2 = exports_external.object({
   verdictRound: exports_external.number().int().min(1).max(10).optional(),
   confidence: exports_external.number().min(0).max(1),
   findings: exports_external.array(exports_external.object({
-    severity: exports_external.enum(["HIGH", "MEDIUM", "LOW"]),
+    severity: exports_external.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]),
     category: exports_external.string().min(1),
     location: exports_external.string(),
     detail: exports_external.string(),
@@ -128382,7 +128521,7 @@ var ArgsSchema4 = exports_external.object({
   working_directory: exports_external.string().optional()
 });
 var submit_phase_council_verdicts = createSwarmTool({
-  description: "Submit pre-collected council member verdicts for PHASE-LEVEL synthesis. " + "PREREQUISITE — you MUST dispatch each council member (critic, reviewer, sme, " + "test_engineer, explorer) as separate Agent tasks with PHASE-SCOPED context and " + "collect their verdict responses BEFORE calling this tool. This tool performs " + "synthesis only — it does NOT dispatch, invoke, or contact council members. " + "Writes .swarm/evidence/{phase}/phase-council.json which is required by " + "phase_complete Gate 5 when council_mode is enabled. " + "Architect-only. Config-gated via council.enabled.",
+  description: "Submit pre-collected council member verdicts for PHASE-LEVEL synthesis. " + "PREREQUISITE — you MUST dispatch each council member (critic, reviewer, sme, " + "test_engineer, explorer) as separate Agent tasks with PHASE-SCOPED context and " + "collect their verdict responses BEFORE calling this tool. This tool performs " + "synthesis only — it does NOT dispatch, invoke, or contact council members. " + "Writes .swarm/evidence/{phase}/phase-council.json which is required by " + "phase_complete Gate 5 when phase_council is enabled. " + "Architect-only. Config-gated via council.enabled.",
   args: {
     phaseNumber: exports_external.number().int().min(1).describe("Phase number being reviewed (e.g. 1, 2, 3)"),
     swarmId: exports_external.string().min(1).describe('Swarm identifier, e.g. "mega"'),
@@ -128400,7 +128539,7 @@ var submit_phase_council_verdicts = createSwarmTool({
       verdictRound: exports_external.number().int().min(1).max(10).optional(),
       confidence: exports_external.number().min(0).max(1),
       findings: exports_external.array(exports_external.object({
-        severity: exports_external.enum(["HIGH", "MEDIUM", "LOW"]),
+        severity: exports_external.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]),
         category: exports_external.string().min(1),
         location: exports_external.string(),
         detail: exports_external.string(),
@@ -128475,6 +128614,20 @@ var submit_phase_council_verdicts = createSwarmTool({
     const mutationGapFinding = existingMutationGapFinding ? null : getPhaseMutationGapFinding(input.phaseNumber, workingDir);
     if (mutationGapFinding) {
       addMutationGapFindingToSynthesis(synthesis, mutationGapFinding);
+      if (mutationGapFinding.severity === "CRITICAL" || mutationGapFinding.severity === "HIGH") {
+        synthesis.blockingConcernsCount++;
+      }
+    }
+    if (synthesis.blockingConcernsCount > 0) {
+      return JSON.stringify({
+        success: false,
+        reason: "blocking_concerns_unresolved",
+        overallVerdict: synthesis.overallVerdict,
+        blockingConcernsCount: synthesis.blockingConcernsCount,
+        requiredFixes: synthesis.requiredFixes,
+        unifiedFeedbackMd: synthesis.unifiedFeedbackMd,
+        message: `Phase council returned CONCERNS with ${synthesis.blockingConcernsCount} HIGH/CRITICAL finding(s) promoted to requiredFixes. These must be resolved before the phase can complete. Do NOT write evidence or proceed — address every requiredFix and resubmit.`
+      }, null, 2);
     }
     writePhaseCouncilEvidence(workingDir, synthesis);
     return JSON.stringify({
@@ -128604,7 +128757,7 @@ function writePhaseCouncilEvidence(workingDir, synthesis) {
   }
 }
 function addMutationGapFindingToSynthesis(synthesis, finding) {
-  if (finding.severity === "HIGH" || finding.severity === "MEDIUM") {
+  if (finding.severity === "CRITICAL" || finding.severity === "HIGH" || finding.severity === "MEDIUM") {
     synthesis.requiredFixes.push(finding);
   } else {
     synthesis.advisoryFindings.push(finding);
@@ -130720,6 +130873,69 @@ function recoverTaskStateFromDelegations(taskId, directory) {
     }
   }
 }
+function checkCouncilGate(workingDirectory, taskId) {
+  let councilEnabled = false;
+  let effectiveMinimum = 3;
+  try {
+    const config3 = loadPluginConfig(workingDirectory);
+    councilEnabled = config3.council?.enabled === true;
+    effectiveMinimum = config3.council?.requireAllMembers ? 5 : config3.council?.minimumMembers ?? 3;
+  } catch {
+    return { blocked: false, reason: "", active: false };
+  }
+  if (!councilEnabled) {
+    return { blocked: false, reason: "", active: false };
+  }
+  try {
+    const planPath = path171.join(workingDirectory, ".swarm", "plan.json");
+    const planRaw = fs128.readFileSync(planPath, "utf-8");
+    const planObj = JSON.parse(planRaw);
+    if (planObj.swarm && planObj.title) {
+      const planId = derivePlanId(planObj);
+      const profile = getProfile(workingDirectory, planId);
+      if (!profile || !profile.gates.council_mode) {
+        return { blocked: false, reason: "", active: false };
+      }
+    }
+  } catch {
+    return { blocked: false, reason: "", active: false };
+  }
+  let evidence;
+  try {
+    evidence = readTaskEvidenceRaw(workingDirectory, taskId);
+  } catch {
+    return {
+      blocked: true,
+      reason: "council gate required but not yet run — architect must call submit_council_verdicts before advancing this task",
+      active: true
+    };
+  }
+  const councilGate = evidence?.gates?.council;
+  if (!councilGate) {
+    return {
+      blocked: true,
+      reason: "council gate required but not yet run — architect must call submit_council_verdicts before advancing this task",
+      active: true
+    };
+  }
+  if (councilGate.verdict === "REJECT") {
+    return {
+      blocked: true,
+      reason: "council gate blocked advancement — resolve requiredFixes and re-run submit_council_verdicts",
+      active: true
+    };
+  }
+  const rawQuorumSize = councilGate.quorumSize;
+  const quorumSize = typeof rawQuorumSize === "number" && Number.isFinite(rawQuorumSize) && rawQuorumSize >= 1 ? rawQuorumSize : 1;
+  if (quorumSize < effectiveMinimum) {
+    return {
+      blocked: true,
+      reason: `council gate blocked advancement — recorded verdict has insufficient quorum (${quorumSize} of ${effectiveMinimum} required members). Re-run submit_council_verdicts with the missing council members.`,
+      active: true
+    };
+  }
+  return { blocked: false, reason: "", active: true };
+}
 async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   const statusError = validateStatus(args2.status);
   if (statusError) {
@@ -130821,7 +131037,15 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
         phaseRequiresReviewer = false;
       }
     } catch {}
-    if (phaseRequiresReviewer) {
+    const councilCheck = checkCouncilGate(directory, args2.task_id);
+    if (councilCheck.blocked) {
+      return {
+        success: false,
+        message: "Gate check failed: council gate not yet satisfied for task " + args2.task_id,
+        errors: [councilCheck.reason]
+      };
+    }
+    if (phaseRequiresReviewer && !councilCheck.active) {
       const reviewerCheck = await checkReviewerGateWithScope(args2.task_id, directory, ctx?.sessionID, fallbackDir);
       if (reviewerCheck.blocked) {
         return {
@@ -131601,7 +131825,7 @@ var VerdictSchema3 = exports_external.object({
   verdict: exports_external.enum(["APPROVE", "CONCERNS", "REJECT"]),
   confidence: exports_external.number().min(0).max(1),
   findings: exports_external.array(exports_external.object({
-    severity: exports_external.enum(["HIGH", "MEDIUM", "LOW"]),
+    severity: exports_external.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]),
     category: exports_external.string().min(1),
     location: exports_external.string(),
     detail: exports_external.string(),
@@ -131655,6 +131879,17 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     }, null, 2);
   }
   const synthesis = synthesizeFinalCouncilAdvisory(input.projectSummary.trim(), input.verdicts, input.roundNumber ?? 1, config3.council);
+  if (synthesis.overallVerdict === "CONCERNS" && synthesis.blockingConcernsCount > 0) {
+    return JSON.stringify({
+      success: false,
+      reason: "blocking_concerns_unresolved",
+      overallVerdict: synthesis.overallVerdict,
+      blockingConcernsCount: synthesis.blockingConcernsCount,
+      requiredFixes: synthesis.requiredFixes,
+      unifiedFeedbackMd: synthesis.unifiedFeedbackMd,
+      message: `Final council returned CONCERNS with ${synthesis.blockingConcernsCount} HIGH/CRITICAL finding(s) promoted to requiredFixes. These must be resolved before the project can close. Do NOT write evidence or proceed — address every requiredFix and resubmit.`
+    }, null, 2);
+  }
   const plan = await loadPlan(directory);
   const planId = plan ? derivePlanId(plan) : "unknown";
   const normalizedVerdict = normalizeFinalVerdict(synthesis.overallVerdict, synthesis.requiredFixes.length);