opencode-swarm 7.38.0 → 7.39.0

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.38.0",
+    version: "7.39.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",
@@ -38860,6 +38860,110 @@ var init_close = __esm(() => {
   ];
 });
 
+// src/commands/concurrency.ts
+async function handleConcurrencyCommand(directory, args, sessionID) {
+  if (!sessionID || sessionID.trim() === "") {
+    return "Error: No active session context. Concurrency requires an active session. Use /swarm concurrency from within an OpenCode session, or start a session first.";
+  }
+  const session = getAgentSession(sessionID);
+  if (!session) {
+    return "Error: No active session. Concurrency requires an active session to operate.";
+  }
+  const arg0 = args[0]?.toLowerCase();
+  const arg1 = args[1];
+  const plan = await loadPlanJsonOnly(directory).catch(() => null);
+  const hasPlan = plan !== null && plan !== undefined;
+  if (arg0 === undefined) {
+    return [
+      "Concurrency commands:",
+      "  /swarm concurrency set <N|preset>  \u2014 Set session concurrency override (1-64 or min/medium/max)",
+      "  /swarm concurrency status          \u2014 Show effective concurrency",
+      "  /swarm concurrency reset           \u2014 Clear the override"
+    ].join(`
+`);
+  }
+  if (arg0 === "status") {
+    return buildStatusMessage(session, plan);
+  }
+  if (!hasPlan) {
+    if (arg0 === "set") {
+      return "No active plan. Concurrency override requires an active plan.";
+    }
+  }
+  if (arg0 === "reset") {
+    session.maxConcurrencyOverride = undefined;
+    return "Concurrency override cleared";
+  }
+  if (arg0 === "set") {
+    if (arg1 === undefined) {
+      return "Error: /swarm concurrency set requires a value. Usage: /swarm concurrency set <N|preset>";
+    }
+    return handleSetCommand(session, arg1);
+  }
+  return [
+    `Unknown concurrency subcommand: ${arg0}`,
+    "Usage: /swarm concurrency <set|status|reset>"
+  ].join(`
+`);
+}
+function handleSetCommand(session, value) {
+  const normalizedValue = value.toLowerCase();
+  if (normalizedValue in PRESETS) {
+    const presetConcurrency = PRESETS[normalizedValue];
+    session.maxConcurrencyOverride = presetConcurrency;
+    return `Concurrency override set to ${presetConcurrency} (${normalizedValue})`;
+  }
+  const numericValue = Number(value);
+  if (Number.isNaN(numericValue)) {
+    return `Invalid concurrency value: ${value}. Must be a number (1-64) or a preset (min, medium, max).`;
+  }
+  if (!Number.isInteger(numericValue)) {
+    return `Invalid concurrency value: ${value}. Must be a number (1-64) or a preset (min, medium, max).`;
+  }
+  if (numericValue < MIN_CONCURRENCY || numericValue > MAX_CONCURRENCY) {
+    return `Concurrency value ${value} is out of range. Must be between ${MIN_CONCURRENCY} and ${MAX_CONCURRENCY}.`;
+  }
+  session.maxConcurrencyOverride = numericValue;
+  return `Concurrency override set to ${numericValue}`;
+}
+function buildStatusMessage(session, plan) {
+  const overrideActive = session.maxConcurrencyOverride !== undefined;
+  const configuredOverride = session.maxConcurrencyOverride ?? "absent";
+  const hasPlan = plan !== null && plan !== undefined;
+  const planBaseline = hasPlan ? plan.execution_profile?.max_concurrent_tasks ?? 1 : 1;
+  const parallelizationEnabled = hasPlan ? plan.execution_profile?.parallelization_enabled ?? false : false;
+  const operationalEffective = !parallelizationEnabled ? 1 : session.maxConcurrencyOverride ?? planBaseline;
+  let description;
+  if (!hasPlan) {
+    description = "No active plan";
+  } else if (!parallelizationEnabled) {
+    description = "Parallelization disabled (always 1)";
+  } else if (overrideActive) {
+    description = `Override active (${session.maxConcurrencyOverride})`;
+  } else {
+    description = `Plan baseline (${planBaseline})`;
+  }
+  return [
+    `Concurrency: ${description}`,
+    `  override_active: ${overrideActive}`,
+    `  configured_override: ${configuredOverride}`,
+    `  plan_baseline: ${planBaseline}`,
+    `  operational_effective: ${operationalEffective}`,
+    `  parallelization_enabled: ${parallelizationEnabled}`
+  ].join(`
+`);
+}
+var PRESETS, MIN_CONCURRENCY = 1, MAX_CONCURRENCY = 64;
+var init_concurrency = __esm(() => {
+  init_manager();
+  init_state();
+  PRESETS = {
+    min: 1,
+    medium: 3,
+    max: 8
+  };
+});
+
 // src/commands/config.ts
 import * as os4 from "os";
 import * as path17 from "path";
@@ -44428,7 +44532,10 @@ function serializeAgentSession(s) {
     fullAutoDeadlockCount: s.fullAutoDeadlockCount ?? 0,
     fullAutoLastQuestionHash: s.fullAutoLastQuestionHash ?? null,
     sessionRehydratedAt: s.sessionRehydratedAt ?? 0,
-    ...Object.keys(stageBCompletion).length > 0 && { stageBCompletion }
+    ...Object.keys(stageBCompletion).length > 0 && { stageBCompletion },
+    ...s.maxConcurrencyOverride !== undefined && {
+      maxConcurrencyOverride: s.maxConcurrencyOverride
+    }
   };
 }
 async function writeSnapshot(directory, state) {
@@ -55699,7 +55806,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   const arg0 = args[0]?.toLowerCase();
   const arg1 = args[1]?.toLowerCase();
   if (arg0 === "status") {
-    return buildStatusMessage(session, directory, sessionID);
+    return buildStatusMessage2(session, directory, sessionID);
   }
   const isTurboOn = session.turboMode;
   const isLeanActive = session.leanTurboActive === true;
@@ -55830,7 +55937,7 @@ function enableLeanTurbo(session, directory, sessionID) {
     `Full-Auto: ${fullAutoActive ? "active" : "inactive"})`
   ].join(" ");
 }
-function buildStatusMessage(session, directory, sessionID) {
+function buildStatusMessage2(session, directory, sessionID) {
   if (!session.turboMode) {
     return "Turbo: off";
   }
@@ -56278,7 +56385,6 @@ __export(exports_commands, {
   handleMemoryMigrateCommand: () => handleMemoryMigrateCommand,
   handleMemoryImportCommand: () => handleMemoryImportCommand,
   handleMemoryExportCommand: () => handleMemoryExportCommand,
-  handleMemoryEvaluateCommand: () => handleMemoryEvaluateCommand,
   handleMemoryCommand: () => handleMemoryCommand,
   handleKnowledgeRestoreCommand: () => handleKnowledgeRestoreCommand,
   handleKnowledgeQuarantineCommand: () => handleKnowledgeQuarantineCommand,
@@ -56298,6 +56404,7 @@ __export(exports_commands, {
   handleCurateCommand: () => handleCurateCommand,
   handleCouncilCommand: () => handleCouncilCommand,
   handleConfigCommand: () => handleConfigCommand,
+  handleConcurrencyCommand: () => handleConcurrencyCommand,
   handleCloseCommand: () => handleCloseCommand,
   handleClarifyCommand: () => handleClarifyCommand,
   handleCheckpointCommand: () => handleCheckpointCommand,
@@ -56544,6 +56651,7 @@ var init_commands = __esm(() => {
   init_close();
   init_command_dispatch();
   init_command_names();
+  init_concurrency();
   init_config2();
   init_council();
   init_curate();
@@ -56764,6 +56872,7 @@ var init_registry = __esm(() => {
   init_benchmark();
   init_checkpoint2();
   init_close();
+  init_concurrency();
   init_config2();
   init_council();
   init_curate();
@@ -57008,6 +57117,23 @@ var init_registry = __esm(() => {
       aliasOf: "finalize",
       deprecated: true
     },
+    concurrency: {
+      handler: (ctx) => handleConcurrencyCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Manage runtime concurrency override for plan execution [set|status|reset]",
+      args: "set <N|preset>, status, reset",
+      details: `Sets, queries, or clears a session-scoped concurrency override for max_concurrent_tasks during plan execution.
+When set, the override takes precedence over the plan's locked execution_profile.max_concurrent_tasks.
+` + `The override is session-scoped \u2014 it does not modify the plan and is cleared on session reset.
+` + `
+Subcommands:
+` + `  concurrency set <N>          \u2014 Set session concurrency to N (1-64)
+` + `  concurrency set <preset>      \u2014 Set to preset: min (1), medium (3), max (8)
+` + `  concurrency status            \u2014 Show effective concurrency (override, plan baseline, operational effective)
+` + `  concurrency reset             \u2014 Clear the session concurrency override
+` + `
+` + "Session-scoped \u2014 resets on new session.",
+      category: "utility"
+    },
     simulate: {
       handler: (ctx) => handleSimulateCommand(ctx.directory, ctx.args),
       description: "Dry-run hidden coupling analysis with configurable thresholds",

package/dist/commands/concurrency.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Handles the /swarm concurrency command.
+ * Supports setting, resetting, and checking concurrency override values.
+ *
+ * @param directory - Project directory (used to load plan execution_profile)
+ * @param args - Optional arguments: "set" | "status" | "reset" with optional value
+ * @param sessionID - Session ID for accessing active session state
+ * @returns Feedback message about concurrency state
+ */
+export declare function handleConcurrencyCommand(directory: string, args: string[], sessionID: string): Promise<string>;

package/dist/commands/index.d.ts

@@ -11,6 +11,7 @@ export { handleCloseCommand } from './close';
 export { executeSwarmCommand, formatCommandNotFound, normalizeSwarmCommandInput, } from './command-dispatch.js';
 export type { CommandName } from './command-names.js';
 export { COMMAND_NAME_SET, COMMAND_NAMES } from './command-names.js';
+export { handleConcurrencyCommand } from './concurrency';
 export { handleConfigCommand } from './config';
 export { handleCouncilCommand } from './council';
 export { handleCurateCommand } from './curate';
@@ -24,7 +25,7 @@ export { handleFullAutoCommand } from './full-auto';
 export { handleHandoffCommand } from './handoff';
 export { handleHistoryCommand } from './history';
 export { handleKnowledgeListCommand, handleKnowledgeMigrateCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, } from './knowledge';
-export { handleMemoryCommand, handleMemoryEvaluateCommand, handleMemoryExportCommand, handleMemoryImportCommand, handleMemoryMigrateCommand, handleMemoryStatusCommand, } from './memory';
+export { handleMemoryCommand, handleMemoryExportCommand, handleMemoryImportCommand, handleMemoryMigrateCommand, handleMemoryStatusCommand, } from './memory';
 export { handlePlanCommand } from './plan';
 export { handlePreflightCommand } from './preflight';
 export { handlePromoteCommand } from './promote';

package/dist/commands/registry.d.ts

@@ -256,6 +256,13 @@ export declare const COMMAND_REGISTRY: {
         readonly aliasOf: "finalize";
         readonly deprecated: true;
     };
+    readonly concurrency: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Manage runtime concurrency override for plan execution [set|status|reset]";
+        readonly args: "set <N|preset>, status, reset";
+        readonly details: string;
+        readonly category: "utility";
+    };
     readonly simulate: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Dry-run hidden coupling analysis with configurable thresholds";

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

@@ -55,6 +55,7 @@ interface MessageWithParts {
     parts: MessagePart[];
 }
 declare function resolveDelegatedPlanTaskId(args: Record<string, unknown>, knownPlanTaskIds?: ReadonlySet<string>): string | null;
+declare function buildParallelExecutionGuidance(directory: string | undefined, sessionID: string, session: AgentSessionState): Promise<string | null>;
 /**
  * Resolves the correct task ID for evidence recording by chaining:
  * 1. Explicit task_id in direct args (structured field)
@@ -68,11 +69,13 @@ declare function resolveDelegatedPlanTaskId(args: Record<string, unknown>, known
 declare function resolveEvidenceTaskId(args: Record<string, unknown> | undefined, session: AgentSessionState, directory: string): Promise<string | null>;
 /**
  * _internals export for testing — do not use in production code.
- * Exposes resolveEvidenceTaskId and resolveDelegatedPlanTaskId for unit testing.
+ * Exposes resolveEvidenceTaskId, resolveDelegatedPlanTaskId, and
+ * buildParallelExecutionGuidance for unit testing.
  */
 export declare const _internals: {
     resolveEvidenceTaskId: typeof resolveEvidenceTaskId;
     resolveDelegatedPlanTaskId: typeof resolveDelegatedPlanTaskId;
+    buildParallelExecutionGuidance: typeof buildParallelExecutionGuidance;
 };
 /**
  * Creates the experimental.chat.messages.transform hook for delegation gating.

package/dist/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.38.0",
+    version: "7.39.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",
@@ -40120,7 +40120,8 @@ async function buildParallelExecutionGuidance(directory, sessionID, session) {
   const profile = plan.execution_profile;
   const enabled = profile?.parallelization_enabled === true;
   const maxConcurrent = profile?.max_concurrent_tasks ?? 1;
-  if (!enabled || maxConcurrent <= 1)
+  const effectiveMaxConcurrent = session?.maxConcurrencyOverride ?? maxConcurrent;
+  if (!enabled || effectiveMaxConcurrent <= 1)
     return null;
   if (hasActiveLeanTurbo(sessionID)) {
     return "[NEXT] Lean Turbo is active; use lean_turbo_run_phase and Lean Turbo lane guidance instead of standard execution-profile slot filling.";
@@ -40149,9 +40150,9 @@ async function buildParallelExecutionGuidance(directory, sessionID, session) {
     if (ACTIVE_PARALLEL_TASK_STATES.has(state))
       occupied.add(taskId);
   }
-  const availableSlots = Math.max(0, maxConcurrent - occupied.size);
+  const availableSlots = Math.max(0, effectiveMaxConcurrent - occupied.size);
   if (availableSlots <= 0) {
-    return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${maxConcurrent}; all standard execution slots are occupied. Continue current active task gates before starting more coder work.`;
+    return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${effectiveMaxConcurrent}; all standard execution slots are occupied. Continue current active task gates before starting more coder work.`;
   }
   const eligible = tasks.filter((task) => {
     const taskId = task.id;
@@ -40163,9 +40164,9 @@ async function buildParallelExecutionGuidance(directory, sessionID, session) {
     return task.depends.every((dep) => completed.has(dep));
   }).map((task) => task.id).slice(0, availableSlots);
   if (eligible.length === 0) {
-    return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${maxConcurrent}; no dependency-ready pending tasks are available for a new coder slot. Continue the current task/gate.`;
+    return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${effectiveMaxConcurrent}; no dependency-ready pending tasks are available for a new coder slot. Continue the current task/gate.`;
   }
-  return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${maxConcurrent}; ${occupied.size} slot(s) occupied. Eligible now: ${eligible.join(", ")}. [NEXT] dispatch up to ${availableSlots} eligible coder task(s) before waiting; preserve ONE task per coder call and call declare_scope for each task.`;
+  return `[PARALLEL EXECUTION PROFILE] parallelization_enabled=true max_concurrent_tasks=${effectiveMaxConcurrent}; ${occupied.size} slot(s) occupied. Eligible now: ${eligible.join(", ")}. [NEXT] dispatch up to ${availableSlots} eligible coder task(s) before waiting; preserve ONE task per coder call and call declare_scope for each task.`;
 }
 function isParallelGuidancePhaseComplete(phase) {
   return phase.status === "complete" || phase.status === "completed" || phase.status === "closed";
@@ -41006,6 +41007,7 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
     turboStrategy: undefined,
     leanTurboActive: false,
     leanTurboCurrentPhase: undefined,
+    maxConcurrencyOverride: undefined,
     qaGateSessionOverrides: {},
     fullAutoMode: false,
     fullAutoInteractionCount: 0,
@@ -60234,6 +60236,110 @@ var init_close = __esm(() => {
   ];
 });
 
+// src/commands/concurrency.ts
+async function handleConcurrencyCommand(directory, args2, sessionID) {
+  if (!sessionID || sessionID.trim() === "") {
+    return "Error: No active session context. Concurrency requires an active session. Use /swarm concurrency from within an OpenCode session, or start a session first.";
+  }
+  const session = getAgentSession(sessionID);
+  if (!session) {
+    return "Error: No active session. Concurrency requires an active session to operate.";
+  }
+  const arg0 = args2[0]?.toLowerCase();
+  const arg1 = args2[1];
+  const plan = await loadPlanJsonOnly(directory).catch(() => null);
+  const hasPlan = plan !== null && plan !== undefined;
+  if (arg0 === undefined) {
+    return [
+      "Concurrency commands:",
+      "  /swarm concurrency set <N|preset>  — Set session concurrency override (1-64 or min/medium/max)",
+      "  /swarm concurrency status          — Show effective concurrency",
+      "  /swarm concurrency reset           — Clear the override"
+    ].join(`
+`);
+  }
+  if (arg0 === "status") {
+    return buildStatusMessage(session, plan);
+  }
+  if (!hasPlan) {
+    if (arg0 === "set") {
+      return "No active plan. Concurrency override requires an active plan.";
+    }
+  }
+  if (arg0 === "reset") {
+    session.maxConcurrencyOverride = undefined;
+    return "Concurrency override cleared";
+  }
+  if (arg0 === "set") {
+    if (arg1 === undefined) {
+      return "Error: /swarm concurrency set requires a value. Usage: /swarm concurrency set <N|preset>";
+    }
+    return handleSetCommand(session, arg1);
+  }
+  return [
+    `Unknown concurrency subcommand: ${arg0}`,
+    "Usage: /swarm concurrency <set|status|reset>"
+  ].join(`
+`);
+}
+function handleSetCommand(session, value) {
+  const normalizedValue = value.toLowerCase();
+  if (normalizedValue in PRESETS) {
+    const presetConcurrency = PRESETS[normalizedValue];
+    session.maxConcurrencyOverride = presetConcurrency;
+    return `Concurrency override set to ${presetConcurrency} (${normalizedValue})`;
+  }
+  const numericValue = Number(value);
+  if (Number.isNaN(numericValue)) {
+    return `Invalid concurrency value: ${value}. Must be a number (1-64) or a preset (min, medium, max).`;
+  }
+  if (!Number.isInteger(numericValue)) {
+    return `Invalid concurrency value: ${value}. Must be a number (1-64) or a preset (min, medium, max).`;
+  }
+  if (numericValue < MIN_CONCURRENCY || numericValue > MAX_CONCURRENCY) {
+    return `Concurrency value ${value} is out of range. Must be between ${MIN_CONCURRENCY} and ${MAX_CONCURRENCY}.`;
+  }
+  session.maxConcurrencyOverride = numericValue;
+  return `Concurrency override set to ${numericValue}`;
+}
+function buildStatusMessage(session, plan) {
+  const overrideActive = session.maxConcurrencyOverride !== undefined;
+  const configuredOverride = session.maxConcurrencyOverride ?? "absent";
+  const hasPlan = plan !== null && plan !== undefined;
+  const planBaseline = hasPlan ? plan.execution_profile?.max_concurrent_tasks ?? 1 : 1;
+  const parallelizationEnabled = hasPlan ? plan.execution_profile?.parallelization_enabled ?? false : false;
+  const operationalEffective = !parallelizationEnabled ? 1 : session.maxConcurrencyOverride ?? planBaseline;
+  let description;
+  if (!hasPlan) {
+    description = "No active plan";
+  } else if (!parallelizationEnabled) {
+    description = "Parallelization disabled (always 1)";
+  } else if (overrideActive) {
+    description = `Override active (${session.maxConcurrencyOverride})`;
+  } else {
+    description = `Plan baseline (${planBaseline})`;
+  }
+  return [
+    `Concurrency: ${description}`,
+    `  override_active: ${overrideActive}`,
+    `  configured_override: ${configuredOverride}`,
+    `  plan_baseline: ${planBaseline}`,
+    `  operational_effective: ${operationalEffective}`,
+    `  parallelization_enabled: ${parallelizationEnabled}`
+  ].join(`
+`);
+}
+var PRESETS, MIN_CONCURRENCY = 1, MAX_CONCURRENCY = 64;
+var init_concurrency = __esm(() => {
+  init_manager();
+  init_state();
+  PRESETS = {
+    min: 1,
+    medium: 3,
+    max: 8
+  };
+});
+
 // src/commands/config.ts
 import * as os7 from "node:os";
 import * as path28 from "node:path";
@@ -65915,7 +66021,10 @@ function serializeAgentSession(s) {
     fullAutoDeadlockCount: s.fullAutoDeadlockCount ?? 0,
     fullAutoLastQuestionHash: s.fullAutoLastQuestionHash ?? null,
     sessionRehydratedAt: s.sessionRehydratedAt ?? 0,
-    ...Object.keys(stageBCompletion).length > 0 && { stageBCompletion }
+    ...Object.keys(stageBCompletion).length > 0 && { stageBCompletion },
+    ...s.maxConcurrencyOverride !== undefined && {
+      maxConcurrencyOverride: s.maxConcurrencyOverride
+    }
   };
 }
 async function writeSnapshot(directory, state) {
@@ -78502,7 +78611,7 @@ async function handleTurboCommand(directory, args2, sessionID) {
   const arg0 = args2[0]?.toLowerCase();
   const arg1 = args2[1]?.toLowerCase();
   if (arg0 === "status") {
-    return buildStatusMessage(session, directory, sessionID);
+    return buildStatusMessage2(session, directory, sessionID);
   }
   const isTurboOn = session.turboMode;
   const isLeanActive = session.leanTurboActive === true;
@@ -78633,7 +78742,7 @@ function enableLeanTurbo(session, directory, sessionID) {
     `Full-Auto: ${fullAutoActive ? "active" : "inactive"})`
   ].join(" ");
 }
-function buildStatusMessage(session, directory, sessionID) {
+function buildStatusMessage2(session, directory, sessionID) {
   if (!session.turboMode) {
     return "Turbo: off";
   }
@@ -79081,7 +79190,6 @@ __export(exports_commands, {
   handleMemoryMigrateCommand: () => handleMemoryMigrateCommand,
   handleMemoryImportCommand: () => handleMemoryImportCommand,
   handleMemoryExportCommand: () => handleMemoryExportCommand,
-  handleMemoryEvaluateCommand: () => handleMemoryEvaluateCommand,
   handleMemoryCommand: () => handleMemoryCommand,
   handleKnowledgeRestoreCommand: () => handleKnowledgeRestoreCommand,
   handleKnowledgeQuarantineCommand: () => handleKnowledgeQuarantineCommand,
@@ -79101,6 +79209,7 @@ __export(exports_commands, {
   handleCurateCommand: () => handleCurateCommand,
   handleCouncilCommand: () => handleCouncilCommand,
   handleConfigCommand: () => handleConfigCommand,
+  handleConcurrencyCommand: () => handleConcurrencyCommand,
   handleCloseCommand: () => handleCloseCommand,
   handleClarifyCommand: () => handleClarifyCommand,
   handleCheckpointCommand: () => handleCheckpointCommand,
@@ -79347,6 +79456,7 @@ var init_commands = __esm(() => {
   init_close();
   init_command_dispatch();
   init_command_names();
+  init_concurrency();
   init_config2();
   init_council();
   init_curate();
@@ -79567,6 +79677,7 @@ var init_registry = __esm(() => {
   init_benchmark();
   init_checkpoint2();
   init_close();
+  init_concurrency();
   init_config2();
   init_council();
   init_curate();
@@ -79811,6 +79922,23 @@ var init_registry = __esm(() => {
       aliasOf: "finalize",
       deprecated: true
     },
+    concurrency: {
+      handler: (ctx) => handleConcurrencyCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Manage runtime concurrency override for plan execution [set|status|reset]",
+      args: "set <N|preset>, status, reset",
+      details: `Sets, queries, or clears a session-scoped concurrency override for max_concurrent_tasks during plan execution.
+When set, the override takes precedence over the plan's locked execution_profile.max_concurrent_tasks.
+` + `The override is session-scoped — it does not modify the plan and is cleared on session reset.
+` + `
+Subcommands:
+` + `  concurrency set <N>          — Set session concurrency to N (1-64)
+` + `  concurrency set <preset>      — Set to preset: min (1), medium (3), max (8)
+` + `  concurrency status            — Show effective concurrency (override, plan baseline, operational effective)
+` + `  concurrency reset             — Clear the session concurrency override
+` + `
+` + "Session-scoped — resets on new session.",
+      category: "utility"
+    },
     simulate: {
       handler: (ctx) => handleSimulateCommand(ctx.directory, ctx.args),
       description: "Dry-run hidden coupling analysis with configurable thresholds",
@@ -103304,6 +103432,7 @@ function deserializeAgentSession(s) {
     fullAutoInteractionCount: s.fullAutoInteractionCount ?? 0,
     fullAutoDeadlockCount: s.fullAutoDeadlockCount ?? 0,
     fullAutoLastQuestionHash: s.fullAutoLastQuestionHash ?? null,
+    maxConcurrencyOverride: typeof s.maxConcurrencyOverride === "number" ? Math.min(64, Math.max(1, s.maxConcurrencyOverride)) : undefined,
     prmPatternCounts: new Map,
     prmEscalationLevel: 0,
     prmLastPatternDetected: null,
@@ -124027,7 +124156,7 @@ async function initializeOpenCodeSwarm(ctx) {
         ...opencodeConfig.command || {},
         swarm: {
           template: "/swarm $ARGUMENTS",
-          description: "Swarm management commands: /swarm [status|show-plan|plan|agents|history|config|help|evidence|handoff|archive|diagnose|diagnosis|preflight|sync-plan|benchmark|export|reset|rollback|retrieve|clarify|analyze|specify|brainstorm|council|pr-review|issue|qa-gates|dark-matter|knowledge|memory|curate|turbo|full-auto|write-retro|reset-session|simulate|promote|checkpoint|acknowledge-spec-drift|doctor tools|finalize|close]"
+          description: "Swarm management commands: /swarm [status|show-plan|plan|agents|history|config|help|evidence|handoff|archive|diagnose|diagnosis|preflight|sync-plan|benchmark|export|reset|rollback|retrieve|clarify|analyze|specify|brainstorm|council|pr-review|issue|qa-gates|dark-matter|knowledge|memory|curate|concurrency|turbo|full-auto|write-retro|reset-session|simulate|promote|checkpoint|acknowledge-spec-drift|doctor tools|finalize|close]"
         },
         "swarm-status": {
           template: "/swarm status",
@@ -124157,10 +124286,6 @@ async function initializeOpenCodeSwarm(ctx) {
           template: "/swarm memory export",
           description: "Use /swarm memory export to write current memory to JSONL"
         },
-        "swarm-memory-evaluate": {
-          template: "/swarm memory evaluate --json",
-          description: "Use /swarm memory evaluate --json to generate the recall evaluation report"
-        },
         "swarm-memory-import": {
           template: "/swarm memory import",
           description: "Use /swarm memory import to import legacy JSONL into SQLite"
@@ -124173,6 +124298,10 @@ async function initializeOpenCodeSwarm(ctx) {
           template: "/swarm curate",
           description: "Use /swarm curate to curate knowledge artifacts and entries"
         },
+        "swarm-concurrency": {
+          template: "/swarm concurrency $ARGUMENTS",
+          description: "Use /swarm concurrency to manage runtime concurrency override for plan execution"
+        },
         "swarm-turbo": {
           template: "/swarm turbo",
           description: "Use /swarm turbo to enable turbo mode for faster execution"

package/dist/session/snapshot-writer.d.ts

@@ -61,6 +61,8 @@ export interface SerializedAgentSession {
     sessionRehydratedAt?: number;
     /** Stage B completion tracking: per-task set of completed Stage B agents. Optional for backward compat with old snapshots. */
     stageBCompletion?: Record<string, string[]>;
+    /** Session-scoped concurrency override for max_concurrent_tasks (Issue #761) */
+    maxConcurrencyOverride?: number;
 }
 /**
  * Minimal interface for serialized InvocationWindow

package/dist/state.d.ts

@@ -165,6 +165,10 @@ export interface AgentSessionState {
     leanTurboActive?: boolean;
     /** Current phase number when Lean Turbo is active (for durable state sync). */
     leanTurboCurrentPhase?: number;
+    /** Session-scoped concurrency override for max_concurrent_tasks (Issue #761).
+     *  When set, overrides the plan's execution_profile.max_concurrent_tasks
+     *  for delegation-gate guidance. Cleared on session reset. */
+    maxConcurrencyOverride?: number;
     /** Session-level QA gate overrides layered on top of the spec-level profile.
      *  Overrides can only enable gates (true); false values are ignored by
      *  getEffectiveGates. Cleared on session reset. Optional for backwards

package/package.json

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