opencode-swarm 7.18.0 → 7.18.2

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.18.0",
+    version: "7.18.2",
     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",
@@ -253,7 +253,7 @@ function isLowCapabilityModel(modelId) {
   const lower = (modelId || "").toLowerCase();
   return LOW_CAPABILITY_MODELS.some((substr) => lower.includes(substr));
 }
-var QA_AGENTS, PIPELINE_AGENTS, ORCHESTRATOR_NAME = "architect", ALL_SUBAGENT_NAMES, ALL_AGENT_NAMES, OPENCODE_NATIVE_AGENTS, CLAUDE_CODE_NATIVE_COMMANDS, AGENT_TOOL_MAP, WRITE_TOOL_NAMES, TOOL_DESCRIPTIONS, DEFAULT_MODELS, DEFAULT_SCORING_CONFIG, LOW_CAPABILITY_MODELS, TURBO_MODE_BANNER = `## \uD83D\uDE80 TURBO MODE ACTIVE
+var QA_AGENTS, PIPELINE_AGENTS, ORCHESTRATOR_NAME = "architect", ALL_SUBAGENT_NAMES, ALL_AGENT_NAMES, OPENCODE_NATIVE_AGENTS, CLAUDE_CODE_NATIVE_COMMANDS, AGENT_TOOL_MAP, WRITE_TOOL_NAMES, TOOL_DESCRIPTIONS, DEFAULT_MODELS, DEFAULT_AGENT_CONFIGS, DEFAULT_SCORING_CONFIG, LOW_CAPABILITY_MODELS, TURBO_MODE_BANNER = `## \uD83D\uDE80 TURBO MODE ACTIVE
 
 **Speed optimization enabled for this session.**
 
@@ -687,8 +687,7 @@ var init_constants = __esm(() => {
       "skill_improve",
       "search",
       "doc_scan",
-      "doc_extract",
-      "web_search"
+      "doc_extract"
     ],
     spec_writer: [
       "search",
@@ -800,21 +799,87 @@ var init_constants = __esm(() => {
     explorer: "opencode/big-pickle",
     coder: "opencode/minimax-m2.5-free",
     reviewer: "opencode/big-pickle",
-    test_engineer: "opencode/gpt-5-nano",
+    test_engineer: "opencode/big-pickle",
     sme: "opencode/big-pickle",
     critic: "opencode/big-pickle",
-    critic_sounding_board: "opencode/gpt-5-nano",
-    critic_drift_verifier: "opencode/gpt-5-nano",
-    critic_hallucination_verifier: "opencode/gpt-5-nano",
-    critic_oversight: "opencode/gpt-5-nano",
+    critic_sounding_board: "opencode/big-pickle",
+    critic_drift_verifier: "opencode/big-pickle",
+    critic_hallucination_verifier: "opencode/big-pickle",
+    critic_oversight: "opencode/big-pickle",
     docs: "opencode/big-pickle",
     designer: "opencode/big-pickle",
-    curator_init: "opencode/gpt-5-nano",
-    curator_phase: "opencode/gpt-5-nano",
+    curator_init: "opencode/big-pickle",
+    curator_phase: "opencode/big-pickle",
     skill_improver: "opencode/big-pickle",
     spec_writer: "opencode/big-pickle",
     default: "opencode/big-pickle"
   };
+  DEFAULT_AGENT_CONFIGS = {
+    coder: {
+      model: "opencode/minimax-m2.5-free",
+      fallback_models: ["opencode/big-pickle"]
+    },
+    reviewer: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    test_engineer: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    explorer: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    sme: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    critic: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    docs: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    designer: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    critic_sounding_board: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    critic_drift_verifier: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    critic_hallucination_verifier: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    critic_oversight: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    curator_init: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    curator_phase: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    skill_improver: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    },
+    spec_writer: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/minimax-m2.5-free"]
+    }
+  };
   DEFAULT_SCORING_CONFIG = {
     enabled: false,
     max_candidates: 100,
@@ -18532,7 +18597,8 @@ function handleAgentsCommand(agents, guardrails) {
   if (hasUnregistered) {
     lines.push("", "### Unregistered Subagents");
     for (const name2 of unregistered) {
-      lines.push(`- **${name2}** (requires configuration)`);
+      const hint = UNREGISTERED_AGENT_HINTS[name2] ?? "requires configuration";
+      lines.push(`- **${name2}** (${hint})`);
     }
   }
   if (guardrails?.profiles && Object.keys(guardrails.profiles).length > 0) {
@@ -18561,9 +18627,18 @@ function handleAgentsCommand(agents, guardrails) {
   return lines.join(`
 `);
 }
+var UNREGISTERED_AGENT_HINTS;
 var init_agents = __esm(() => {
   init_constants();
   init_schema();
+  UNREGISTERED_AGENT_HINTS = {
+    designer: "enable ui_review.enabled",
+    council_generalist: "enable council.general.enabled",
+    council_skeptic: "enable council.general.enabled",
+    council_domain_expert: "enable council.general.enabled",
+    skill_improver: "registered by default unless agents.skill_improver.disabled is true",
+    spec_writer: "registered by default unless agents.spec_writer.disabled is true"
+  };
 });
 
 // src/commands/analyze.ts
@@ -26355,9 +26430,9 @@ async function getEvidenceTaskId(session, directory) {
   const primary = session.currentTaskId ?? session.lastCoderDelegationTaskId;
   if (primary)
     return primary;
-  if (session.taskWorkflowStates && session.taskWorkflowStates.size > 0) {
-    return session.taskWorkflowStates.keys().next().value ?? null;
-  }
+  const onlyTaskId = getOnlyWorkflowTaskId(session);
+  if (onlyTaskId)
+    return onlyTaskId;
   try {
     if (typeof directory !== "string" || directory.length === 0) {
       return null;
@@ -26707,18 +26782,25 @@ function createDelegationGateHook(config2, directory) {
           const explicitEvidenceTaskId = extractTaskIdFromTaskArgs(mergedTaskArgs);
           const stageBEvidenceTaskId = gateForEvidence === "reviewer" || gateForEvidence === "test_engineer" || gateForEvidence === "adversarial_test_engineer" ? resolveScopedStageBTaskId(session, mergedTaskArgs) : null;
           const evidenceTaskId = stageBEvidenceTaskId ?? explicitEvidenceTaskId ?? await getEvidenceTaskId(session, directory);
+          const gateAgents = [
+            "reviewer",
+            "test_engineer",
+            "docs",
+            "designer",
+            "critic",
+            "explorer",
+            "sme"
+          ];
+          if (evidenceTaskId === null && gateAgents.includes(targetAgentForEvidence)) {
+            session.pendingAdvisoryMessages ??= [];
+            if (!session.pendingAdvisoryMessages.some((m) => m.includes("evidence-task-id-unresolved"))) {
+              session.pendingAdvisoryMessages.push(`[evidence-task-id-unresolved] Gate evidence has NOT been written for one or more recent gate-agent dispatches because the current task id is unresolved. Call update_task_status(<task_id>, 'in_progress') BEFORE dispatching gate agents (e.g. reviewer/test_engineer). Most recent affected agent: ${targetAgentForEvidence}.`);
+            }
+            console.warn(`[delegation-gate] evidence-task-id-unresolved sessionID=${input.sessionID} subagentType=${targetAgentForEvidence} reason=evidence-task-id-unresolved`);
+          }
           if (evidenceTaskId && typeof directory === "string") {
             const turbo = hasActiveTurboMode(input.sessionID);
             const parallelRuntime = resolveStandardParallelizationConfig(config2, directory);
-            const gateAgents = [
-              "reviewer",
-              "test_engineer",
-              "docs",
-              "designer",
-              "critic",
-              "explorer",
-              "sme"
-            ];
             if (gateAgents.includes(targetAgentForEvidence)) {
               const { recordGateEvidence: recordGateEvidence2 } = await Promise.resolve().then(() => (init_gate_evidence(), exports_gate_evidence));
               await recordGateEvidence2(directory, evidenceTaskId, gateForEvidence, input.sessionID, turbo, parallelRuntime.evidenceLockTimeoutMs);
@@ -26728,7 +26810,7 @@ function createDelegationGateHook(config2, directory) {
             }
           }
         } catch (err2) {
-          console.warn(`[delegation-gate] evidence recording failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+          console.warn(`[delegation-gate] evidence recording failed reason=evidence-write-failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
         }
       }
       if (storedArgs !== undefined) {
@@ -46818,12 +46900,31 @@ function parseArgs(args2) {
   }
   return out2;
 }
-async function handleCouncilCommand(_directory, args2) {
+async function handleCouncilCommand(directory, args2) {
   const parsed = parseArgs(args2);
   const question = sanitizeQuestion(parsed.rest.join(" "));
   if (!question) {
     return USAGE;
   }
+  const config3 = loadPluginConfig(directory);
+  if (config3.council?.general?.enabled !== true) {
+    return [
+      "General Council is not enabled for this project.",
+      "",
+      "Enable it in `.opencode/opencode-swarm.json` or `~/.config/opencode/opencode-swarm.json`:",
+      "",
+      "```json",
+      "{",
+      '  "council": {',
+      '    "general": { "enabled": true }',
+      "  }",
+      "}",
+      "```",
+      "",
+      "Then restart OpenCode and run `/swarm config doctor` before trying `/swarm council` again."
+    ].join(`
+`);
+  }
   const tokens = ["MODE: COUNCIL"];
   if (parsed.preset) {
     tokens.push(`preset=${parsed.preset}`);
@@ -46835,6 +46936,7 @@ async function handleCouncilCommand(_directory, args2) {
 }
 var MAX_QUESTION_LEN = 2000, USAGE;
 var init_council = __esm(() => {
+  init_loader();
   USAGE = [
     "Usage: /swarm council <question> [--preset <name>] [--spec-review]",
     "",
@@ -48362,6 +48464,7 @@ __export(exports_config_doctor, {
   restoreFromBackup: () => restoreFromBackup,
   getConfigPaths: () => getConfigPaths,
   createConfigBackup: () => createConfigBackup,
+  collectConfiguredModelRefs: () => collectConfiguredModelRefs,
   applySafeAutoFixes: () => applySafeAutoFixes
 });
 import * as crypto3 from "node:crypto";
@@ -48755,6 +48858,129 @@ function validateConfigKey(path31, value, _config) {
   }
   return findings;
 }
+function addConfiguredModel(refs, model, configPath) {
+  if (typeof model !== "string")
+    return;
+  const trimmed = model.trim();
+  if (!trimmed)
+    return;
+  const paths = refs.get(trimmed) ?? new Set;
+  paths.add(configPath);
+  refs.set(trimmed, paths);
+}
+function addConfiguredAgentModels(refs, agents, prefix) {
+  if (!agents || typeof agents !== "object" || Array.isArray(agents))
+    return;
+  for (const [agentName, value] of Object.entries(agents)) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      continue;
+    const agent = value;
+    addConfiguredModel(refs, agent.model, `${prefix}.${agentName}.model`);
+    if (Array.isArray(agent.fallback_models)) {
+      agent.fallback_models.forEach((model, index) => {
+        addConfiguredModel(refs, model, `${prefix}.${agentName}.fallback_models[${index}]`);
+      });
+    }
+  }
+}
+function collectConfiguredModelRefs(config3) {
+  const refs = new Map;
+  const rawConfig = config3;
+  addConfiguredAgentModels(refs, rawConfig.agents, "agents");
+  if (rawConfig.swarms && typeof rawConfig.swarms === "object" && !Array.isArray(rawConfig.swarms)) {
+    for (const [swarmId, value] of Object.entries(rawConfig.swarms)) {
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        continue;
+      addConfiguredAgentModels(refs, value.agents, `swarms.${swarmId}.agents`);
+    }
+  }
+  if (rawConfig.full_auto && typeof rawConfig.full_auto === "object" && !Array.isArray(rawConfig.full_auto)) {
+    addConfiguredModel(refs, rawConfig.full_auto.critic_model, "full_auto.critic_model");
+  }
+  if (rawConfig.skill_improver && typeof rawConfig.skill_improver === "object" && !Array.isArray(rawConfig.skill_improver)) {
+    const skillImprover = rawConfig.skill_improver;
+    addConfiguredModel(refs, skillImprover.model, "skill_improver.model");
+    if (Array.isArray(skillImprover.fallback_models)) {
+      skillImprover.fallback_models.forEach((model, index) => {
+        addConfiguredModel(refs, model, `skill_improver.fallback_models[${index}]`);
+      });
+    }
+  }
+  if (rawConfig.spec_writer && typeof rawConfig.spec_writer === "object" && !Array.isArray(rawConfig.spec_writer)) {
+    const specWriter = rawConfig.spec_writer;
+    addConfiguredModel(refs, specWriter.model, "spec_writer.model");
+    if (Array.isArray(specWriter.fallback_models)) {
+      specWriter.fallback_models.forEach((model, index) => {
+        addConfiguredModel(refs, model, `spec_writer.fallback_models[${index}]`);
+      });
+    }
+  }
+  const council = rawConfig.council;
+  const general = council && typeof council === "object" && !Array.isArray(council) ? council.general : undefined;
+  if (general && typeof general === "object" && !Array.isArray(general)) {
+    addConfiguredModel(refs, general.moderatorModel, "council.general.moderatorModel");
+    if (Array.isArray(general.members)) {
+      general.members.forEach((member, index) => {
+        if (!member || typeof member !== "object" || Array.isArray(member)) {
+          return;
+        }
+        addConfiguredModel(refs, member.model, `council.general.members[${index}].model`);
+      });
+    }
+    if (general.presets && typeof general.presets === "object" && !Array.isArray(general.presets)) {
+      for (const [presetName, members] of Object.entries(general.presets)) {
+        if (!Array.isArray(members))
+          continue;
+        members.forEach((member, index) => {
+          if (!member || typeof member !== "object" || Array.isArray(member)) {
+            return;
+          }
+          addConfiguredModel(refs, member.model, `council.general.presets.${presetName}[${index}].model`);
+        });
+      }
+    }
+  }
+  return refs;
+}
+function validateConfiguredModels(config3, modelAvailability) {
+  const refs = collectConfiguredModelRefs(config3);
+  const findings = [];
+  if (modelAvailability.error) {
+    findings.push({
+      id: "model-availability-unchecked",
+      title: "Model availability check skipped",
+      description: `Could not load OpenCode provider models from ${modelAvailability.source}: ` + modelAvailability.error,
+      severity: "info",
+      path: "agents",
+      autoFixable: false
+    });
+    return findings;
+  }
+  if (refs.size === 0)
+    return findings;
+  for (const [modelId, paths] of refs.entries()) {
+    if (modelAvailability.availableModelIds.has(modelId))
+      continue;
+    findings.push({
+      id: "configured-model-unavailable",
+      title: "Configured model is unavailable",
+      description: `Configured model ${formatModelIdForDoctor(modelId)} was not found in the active OpenCode provider model registry. ` + "Run `/models` to choose a currently available model, then update opencode-swarm.json.",
+      severity: "error",
+      path: [...paths].sort().join(", "),
+      currentValue: modelId,
+      autoFixable: false
+    });
+  }
+  return findings;
+}
+function formatModelIdForDoctor(modelId) {
+  const json3 = JSON.stringify(modelId);
+  if (!json3)
+    return '"<invalid model id>"';
+  if (json3.length <= 160)
+    return json3;
+  return `${json3.slice(0, 157)}..."`;
+}
 function walkConfigAndValidate(obj, path31, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
@@ -48779,9 +49005,12 @@ function walkConfigAndValidate(obj, path31, config3, findings) {
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
-function runConfigDoctor(config3, directory) {
+function runConfigDoctor(config3, directory, options = {}) {
   const findings = [];
   walkConfigAndValidate(config3, "", config3, findings);
+  if (options.modelAvailability) {
+    findings.push(...validateConfiguredModels(config3, options.modelAvailability));
+  }
   const summary = {
     info: findings.filter((f) => f.severity === "info").length,
     warn: findings.filter((f) => f.severity === "warn").length,
@@ -48943,8 +49172,8 @@ function shouldRunOnStartup(automationConfig) {
   }
   return automationConfig.capabilities?.config_doctor_on_startup === true;
 }
-async function runConfigDoctorWithFixes(directory, config3, autoFix = false) {
-  const result = runConfigDoctor(config3, directory);
+async function runConfigDoctorWithFixes(directory, config3, autoFix = false, options = {}) {
+  const result = runConfigDoctor(config3, directory, options);
   const artifactPath = writeDoctorArtifact(directory, result);
   if (!autoFix) {
     return {
@@ -48964,7 +49193,7 @@ async function runConfigDoctorWithFixes(directory, config3, autoFix = false) {
   if (appliedFixes.length > 0) {
     const freshConfig = readConfigFromFile(directory);
     if (freshConfig) {
-      const newResult = runConfigDoctor(freshConfig.config, directory);
+      const newResult = runConfigDoctor(freshConfig.config, directory, options);
       writeDoctorArtifact(directory, newResult);
     }
   }
@@ -50609,6 +50838,31 @@ var init_tool_doctor = __esm(() => {
   ];
 });
 
+// src/utils/timeout.ts
+async function withTimeout(promise3, ms, timeoutError) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(timeoutError), ms);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  });
+  try {
+    return await Promise.race([promise3, timeoutPromise]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+function yieldToEventLoop() {
+  return new Promise((resolve11) => {
+    const t = setTimeout(resolve11, 0);
+    if (typeof t.unref === "function") {
+      t.unref();
+    }
+  });
+}
+
 // src/commands/doctor.ts
 function formatToolDoctorMarkdown(result) {
   const lines = [
@@ -50682,13 +50936,67 @@ function formatDoctorMarkdown(result) {
   return lines.join(`
 `);
 }
-async function handleDoctorCommand(directory, args2) {
+function extractAvailableModelIds(response) {
+  const available = new Set;
+  if (response?.providers !== undefined && !Array.isArray(response.providers)) {
+    throw new Error("provider registry returned malformed provider list");
+  }
+  for (const provider of response?.providers ?? []) {
+    if (!provider || typeof provider !== "object" || !provider.id || !provider.models || typeof provider.models !== "object" || Array.isArray(provider.models)) {
+      continue;
+    }
+    for (const [modelKey, modelInfo] of Object.entries(provider.models)) {
+      available.add(`${provider.id}/${modelKey}`);
+      if (modelInfo && typeof modelInfo === "object" && modelInfo.id) {
+        available.add(`${provider.id}/${modelInfo.id}`);
+      }
+    }
+  }
+  return available;
+}
+async function loadModelAvailability(directory, client, options = {}) {
+  const providerClient = client;
+  const providers = providerClient?.config?.providers;
+  if (typeof providers !== "function") {
+    return;
+  }
+  try {
+    const response = await withTimeout(providers({ directory }), options.timeoutMs ?? MODEL_REGISTRY_TIMEOUT_MS, new Error(`OpenCode provider model registry lookup exceeded ${options.timeoutMs ?? MODEL_REGISTRY_TIMEOUT_MS}ms`));
+    if (response.error) {
+      return {
+        availableModelIds: new Set,
+        source: MODEL_REGISTRY_SOURCE,
+        error: typeof response.error === "string" ? response.error : JSON.stringify(response.error)
+      };
+    }
+    if (!response.data) {
+      return {
+        availableModelIds: new Set,
+        source: MODEL_REGISTRY_SOURCE,
+        error: "provider registry returned no data"
+      };
+    }
+    return {
+      availableModelIds: extractAvailableModelIds(response.data),
+      source: MODEL_REGISTRY_SOURCE
+    };
+  } catch (error93) {
+    return {
+      availableModelIds: new Set,
+      source: MODEL_REGISTRY_SOURCE,
+      error: error93 instanceof Error ? error93.message : String(error93)
+    };
+  }
+}
+async function handleDoctorCommand(directory, args2, options = {}) {
   const enableAutoFix = args2.includes("--fix") || args2.includes("-f");
   const config3 = loadPluginConfig(directory);
-  const result = runConfigDoctor(config3, directory);
+  const modelAvailability = await loadModelAvailability(directory, options.client);
+  const doctorOptions = { modelAvailability };
+  const result = runConfigDoctor(config3, directory, doctorOptions);
   if (enableAutoFix && result.hasAutoFixableIssues) {
     const { runConfigDoctorWithFixes: runConfigDoctorWithFixes2 } = await Promise.resolve().then(() => (init_config_doctor(), exports_config_doctor));
-    const fixResult = await runConfigDoctorWithFixes2(directory, config3, true);
+    const fixResult = await runConfigDoctorWithFixes2(directory, config3, true, doctorOptions);
     return formatDoctorMarkdown(fixResult.result);
   }
   return formatDoctorMarkdown(result);
@@ -50697,6 +51005,7 @@ async function handleDoctorToolsCommand(directory, _args) {
   const result = runToolDoctor(directory);
   return formatToolDoctorMarkdown(result);
 }
+var MODEL_REGISTRY_TIMEOUT_MS = 3000, MODEL_REGISTRY_SOURCE = "OpenCode config.providers";
 var init_doctor = __esm(() => {
   init_loader();
   init_config_doctor();
@@ -60867,7 +61176,7 @@ function buildHelpText() {
   return lines.join(`
 `);
 }
-function createSwarmCommandHandler(directory, agents) {
+function createSwarmCommandHandler(directory, agents, client) {
   return async (input, output) => {
     if (input.command !== "swarm" && !input.command.startsWith("swarm-")) {
       return;
@@ -60914,7 +61223,8 @@ ${similar.map((cmd) => `  • /swarm ${cmd}`).join(`
           directory,
           args: resolved.remainingArgs,
           sessionID: input.sessionID,
-          agents
+          agents,
+          client
         });
       } catch (_err) {
         const cmdName = tokens[0] || "unknown";
@@ -60930,7 +61240,10 @@ ${text}`;
     if (isFirstRun) {
       const welcomeMessage = `Welcome to OpenCode Swarm! \uD83D\uDC1D
 ` + `
-` + `Run \`/swarm help\` to see all available commands, or \`/swarm config\` to review your configuration.
+` + `Start here: run \`/swarm diagnose\`, then \`/swarm agents\` to confirm the plugin loaded and see the exact models in use.
+` + `If a model is unavailable, edit \`.opencode/opencode-swarm.json\` or \`~/.config/opencode/opencode-swarm.json\` and run \`/swarm config doctor\`.
+` + `Useful next steps: \`/swarm brainstorm <task>\` for guided planning, \`/swarm full-auto on\` for autonomous runs after enabling it in config, and \`/swarm council <question>\` after enabling council.general.
+
 `;
       text = welcomeMessage + text;
     }
@@ -61247,13 +61560,13 @@ var init_registry = __esm(() => {
       clashesWithNativeCcCommand: "/config"
     },
     "config doctor": {
-      handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args),
+      handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args, { client: ctx.client }),
       description: "Run config doctor checks",
       subcommandOf: "config",
       category: "diagnostics"
     },
     "config-doctor": {
-      handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args),
+      handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args, { client: ctx.client }),
       description: "Run config doctor checks",
       subcommandOf: "config",
       category: "diagnostics",
@@ -61328,7 +61641,7 @@ var init_registry = __esm(() => {
       deprecated: true
     },
     doctor: {
-      handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args),
+      handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args, { client: ctx.client }),
       description: "Run config doctor checks",
       category: "diagnostics",
       aliasOf: "config doctor",
@@ -71616,13 +71929,7 @@ function writeSwarmConfigExampleIfNew(projectDirectory) {
       fs40.mkdirSync(swarmDir, { recursive: true });
     }
     const example = {
-      agents: Object.fromEntries(Object.entries(DEFAULT_MODELS).filter(([name2]) => name2 !== "default").map(([name2, model]) => [
-        name2,
-        {
-          model,
-          fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
-        }
-      ])),
+      agents: DEFAULT_AGENT_CONFIGS,
       max_iterations: 5
     };
     fs40.writeFileSync(dest, `${JSON.stringify(example, null, 2)}
@@ -74064,31 +74371,6 @@ import * as fsPromises5 from "node:fs/promises";
 import * as os7 from "node:os";
 import * as path66 from "node:path";
 
-// src/utils/timeout.ts
-async function withTimeout(promise3, ms, timeoutError) {
-  let timer;
-  const timeoutPromise = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(timeoutError), ms);
-    if (typeof timer.unref === "function") {
-      timer.unref();
-    }
-  });
-  try {
-    return await Promise.race([promise3, timeoutPromise]);
-  } finally {
-    if (timer !== undefined)
-      clearTimeout(timer);
-  }
-}
-function yieldToEventLoop() {
-  return new Promise((resolve19) => {
-    const t = setTimeout(resolve19, 0);
-    if (typeof t.unref === "function") {
-      t.unref();
-    }
-  });
-}
-
 // src/tools/symbols.ts
 init_zod();
 init_create_tool();
@@ -89503,6 +89785,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
 }
 
 // src/tools/phase-complete.ts
+init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 function safeWarn(message, error93) {
@@ -89510,6 +89793,15 @@ function safeWarn(message, error93) {
     console.warn(message, error93 instanceof Error ? error93.message : String(error93));
   } catch {}
 }
+function taskIdToPhase(taskId) {
+  if (typeof taskId !== "string")
+    return null;
+  if (!isStrictTaskId(taskId))
+    return null;
+  const head = taskId.split(".")[0];
+  const n = Number.parseInt(head, 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
 function collectCrossSessionDispatchedAgents(phaseReferenceTimestamp, callerSessionId) {
   const agents = new Set;
   const contributorSessionIds = [];
@@ -90622,6 +90914,52 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
         const oldPhase = contributorSession.lastPhaseCompletePhase;
         contributorSession.lastPhaseCompletePhase = phase;
         telemetry.phaseChanged(contributorSessionId, oldPhase ?? 0, phase);
+        const currentTid = contributorSession.currentTaskId;
+        if (currentTid) {
+          const tp = taskIdToPhase(currentTid);
+          if (tp !== null && tp <= phase) {
+            contributorSession.currentTaskId = null;
+          }
+        }
+        const lastCoderTid = contributorSession.lastCoderDelegationTaskId;
+        if (lastCoderTid) {
+          const tp = taskIdToPhase(lastCoderTid);
+          if (tp !== null && tp <= phase) {
+            contributorSession.lastCoderDelegationTaskId = null;
+          }
+        }
+        const openStates = new Set([
+          "coder_delegated",
+          "pre_check_passed",
+          "reviewer_run"
+        ]);
+        if (contributorSession.taskWorkflowStates instanceof Map) {
+          for (const [taskId, state] of Array.from(contributorSession.taskWorkflowStates.entries())) {
+            const tp = taskIdToPhase(taskId);
+            if (tp === null || tp > phase)
+              continue;
+            if (openStates.has(state)) {
+              console.warn(`[phase-complete] dropping open task state at phase boundary: taskId=${taskId} state=${state} phaseCompleted=${phase}`);
+            }
+            contributorSession.taskWorkflowStates.delete(taskId);
+          }
+        }
+        if (contributorSession.stageBCompletion instanceof Map) {
+          for (const taskId of Array.from(contributorSession.stageBCompletion.keys())) {
+            const tp = taskIdToPhase(taskId);
+            if (tp !== null && tp <= phase) {
+              contributorSession.stageBCompletion.delete(taskId);
+            }
+          }
+        }
+        if (contributorSession.requiredStageBGates instanceof Map) {
+          for (const taskId of Array.from(contributorSession.requiredStageBGates.keys())) {
+            const tp = taskIdToPhase(taskId);
+            if (tp !== null && tp <= phase) {
+              contributorSession.requiredStageBGates.delete(taskId);
+            }
+          }
+        }
       }
     }
     try {
@@ -103330,7 +103668,6 @@ init_write_retro();
 
 // src/index.ts
 init_utils();
-
 // src/utils/tool-output.ts
 function truncateToolOutput(output, maxLines, toolName, tailLines = 10) {
   if (!output) {
@@ -103473,7 +103810,7 @@ async function initializeOpenCodeSwarm(ctx) {
   const systemEnhancerHook = createSystemEnhancerHook(config3, ctx.directory);
   const compactionHook = createCompactionCustomizerHook(config3, ctx.directory);
   const contextBudgetHandler = createContextBudgetHandler(config3);
-  const commandHandler = createSwarmCommandHandler(ctx.directory, Object.fromEntries(agentDefinitions.map((agent) => [agent.name, agent])));
+  const commandHandler = createSwarmCommandHandler(ctx.directory, Object.fromEntries(agentDefinitions.map((agent) => [agent.name, agent])), ctx.client);
   const activityHooks = createAgentActivityHooks(config3, ctx.directory);
   const prmHook = createPrmHook(config3.prm ?? PrmConfigSchema.parse({}), ctx.directory);
   const trajectoryLoggerHook = createTrajectoryLoggerHook({