opencode-swarm 7.17.1 → 7.17.3

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.17.1",
+    version: "7.17.3",
     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",
@@ -51420,7 +51420,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config: config3 } = loadPluginConfigWithMeta(directory);
+      const { config: config3 } = _internals25.loadPluginConfigWithMeta(directory);
       if (config3.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -51475,7 +51475,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config: config3 } = loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals25.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -51545,11 +51545,15 @@ function buildStatusMessage(session, directory, sessionID) {
   ].join(`
 `);
 }
+var _internals25;
 var init_turbo = __esm(() => {
   init_config();
   init_state();
   init_state3();
   init_logger();
+  _internals25 = {
+    loadPluginConfigWithMeta
+  };
 });
 
 // src/commands/write-retro.ts
@@ -51802,7 +51806,7 @@ function createSwarmCommandHandler(directory, agents) {
         const attemptedCommand = tokens[0] || "";
         const MAX_DISPLAY = 100;
         const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-        const similar = _internals25.findSimilarCommands(attemptedCommand);
+        const similar = _internals26.findSimilarCommands(attemptedCommand);
         const header = `Command \`/swarm ${displayCommand}\` not found.`;
         const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  \u2022 /swarm ${cmd}`).join(`
@@ -51909,7 +51913,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals25.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals26.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -51922,7 +51926,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals25.levenshteinDistance(qt, ct);
+          const dist = _internals26.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -51932,7 +51936,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals25.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals26.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -51964,11 +51968,11 @@ async function handleHelpCommand(ctx) {
     return buildHelpText2();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals25.resolveCommand(tokens);
+  const resolved = _internals26.resolveCommand(tokens);
   if (resolved) {
-    return _internals25.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals26.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals25.findSimilarCommands(targetCommand);
+  const similar = _internals26.findSimilarCommands(targetCommand);
   const { buildHelpText: fullHelp } = await Promise.resolve().then(() => (init_commands(), exports_commands));
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
@@ -52062,7 +52066,7 @@ function resolveCommand(tokens) {
   }
   return null;
 }
-var COMMAND_REGISTRY, VALID_COMMANDS, _internals25, validation;
+var COMMAND_REGISTRY, VALID_COMMANDS, _internals26, validation;
 var init_registry = __esm(() => {
   init_acknowledge_spec_drift();
   init_agents();
@@ -52132,7 +52136,7 @@ var init_registry = __esm(() => {
       clashesWithNativeCcCommand: "/agents"
     },
     help: {
-      handler: (ctx) => _internals25.handleHelpCommand(ctx),
+      handler: (ctx) => _internals26.handleHelpCommand(ctx),
       description: "Show help for swarm commands",
       category: "core",
       args: "[command]",
@@ -52431,9 +52435,24 @@ var init_registry = __esm(() => {
     },
     turbo: {
       handler: (ctx) => handleTurboCommand(ctx.directory, ctx.args, ctx.sessionID),
-      description: "Toggle Turbo Mode for the active session [on|off]",
-      args: "on, off",
-      details: 'Toggles Turbo Mode which skips non-critical QA gates for faster iteration. When enabled, the architect can proceed without waiting for all automated checks. Session-scoped \u2014 resets on new session. Use "on" or "off" to set explicitly, or toggle with no argument.',
+      description: "Toggle Turbo Mode strategy for the active session [on|off|lean|standard|status]",
+      args: "on, off, lean, standard, status",
+      details: `Toggles Turbo Mode for the current session. Supports two strategies:
+
+` + `**Standard turbo** \u2014 skips non-critical QA gates for faster iteration.
+` + `**Lean turbo** \u2014 parallel lane execution with per-lane reviewer gates and file-lock conflict detection.
+` + `
+Subcommands:
+` + `  turbo on           \u2014 enable turbo (uses lean when config turbo.strategy is "lean", otherwise standard)
+` + `  turbo off          \u2014 disable all turbo modes
+` + `  turbo lean on      \u2014 enable Lean Turbo explicitly
+` + `  turbo lean off     \u2014 disable Lean Turbo
+` + `  turbo lean         \u2014 toggle Lean Turbo on/off
+` + `  turbo standard on  \u2014 force standard turbo (disables lean even if config says lean)
+` + `  turbo standard off \u2014 disable standard turbo (falls back to lean if config strategy is lean)
+` + `  turbo status       \u2014 show detailed status including active strategy and lanes
+` + `
+` + "Session-scoped \u2014 resets on new session.",
       category: "utility"
     },
     "full-auto": {
@@ -52489,7 +52508,7 @@ var init_registry = __esm(() => {
     }
   };
   VALID_COMMANDS = Object.keys(COMMAND_REGISTRY);
-  _internals25 = {
+  _internals26 = {
     handleHelpCommand,
     validateAliases,
     resolveCommand,
@@ -52497,7 +52516,7 @@ var init_registry = __esm(() => {
     findSimilarCommands,
     buildDetailedHelp
   };
-  validation = _internals25.validateAliases();
+  validation = _internals26.validateAliases();
   if (!validation.valid) {
     throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`

package/dist/commands/registry.d.ts

@@ -366,9 +366,9 @@ export declare const COMMAND_REGISTRY: {
     };
     readonly turbo: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
-        readonly description: "Toggle Turbo Mode for the active session [on|off]";
-        readonly args: "on, off";
-        readonly details: "Toggles Turbo Mode which skips non-critical QA gates for faster iteration. When enabled, the architect can proceed without waiting for all automated checks. Session-scoped — resets on new session. Use \"on\" or \"off\" to set explicitly, or toggle with no argument.";
+        readonly description: "Toggle Turbo Mode strategy for the active session [on|off|lean|standard|status]";
+        readonly args: "on, off, lean, standard, status";
+        readonly details: string;
         readonly category: "utility";
     };
     readonly 'full-auto': {

package/dist/commands/turbo.d.ts

@@ -1,3 +1,14 @@
+import { loadPluginConfigWithMeta } from '../config';
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.loadPluginConfigWithMeta(...)` so tests can replace the function
+ * on this object without using `mock.module` from `bun:test`, which leaks
+ * across files in Bun's shared test-runner process (AGENTS.md §7).
+ * Mutating this local object is file-scoped and trivially restorable via afterEach.
+ */
+export declare const _internals: {
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+};
 /**
  * Handles the /swarm turbo command.
  * Supports standard turbo toggle, lean turbo mode, and status reporting.

package/dist/council/council-service.d.ts

@@ -8,7 +8,7 @@
  * No I/O — fully unit-testable with mock inputs. All file reads/writes happen in
  * sibling modules (criteria-store, council-evidence-writer).
  */
-import type { CouncilConfig, CouncilCriteria, CouncilMemberVerdict, CouncilSynthesis, PhaseCouncilSynthesis } from './types';
+import type { CouncilConfig, CouncilCriteria, CouncilMemberVerdict, CouncilSynthesis, FinalCouncilSynthesis, PhaseCouncilSynthesis } from './types';
 export declare function synthesizeCouncilVerdicts(taskId: string, swarmId: string, verdicts: CouncilMemberVerdict[], criteria: CouncilCriteria | null, roundNumber: number, config?: Partial<CouncilConfig>): CouncilSynthesis;
 /**
  * Synthesize phase-level council verdicts into a PhaseCouncilSynthesis.
@@ -19,3 +19,9 @@ export declare function synthesizeCouncilVerdicts(taskId: string, swarmId: strin
  * (see writePhaseCouncilEvidence in submit-phase-council-verdicts.ts).
  */
 export declare function synthesizePhaseCouncilAdvisory(phaseNumber: number, phaseSummary: string, verdicts: CouncilMemberVerdict[], roundNumber: number, config?: Partial<CouncilConfig>, _workingDir?: string): PhaseCouncilSynthesis;
+/**
+ * Synthesize project-level final council verdicts into a FinalCouncilSynthesis.
+ * This uses the same five-member verdict semantics as phase council, but the
+ * output is scoped to completed-project review and the final_council gate.
+ */
+export declare function synthesizeFinalCouncilAdvisory(projectSummary: string, verdicts: CouncilMemberVerdict[], roundNumber: number, config?: Partial<CouncilConfig>): FinalCouncilSynthesis;

package/dist/council/types.d.ts

@@ -87,6 +87,38 @@ export interface PhaseCouncilSynthesis {
     /** Summary of the phase being reviewed */
     phaseSummary?: string;
 }
+/**
+ * Project-level final council synthesis result.
+ * Distinct from task-level and phase-level council results: this is the
+ * final project close gate and writes to .swarm/evidence/final-council.json.
+ */
+export interface FinalCouncilSynthesis {
+    /** Always 'project' - distinguishes final council from task/phase councils */
+    scope: 'project';
+    /** ISO 8601 */
+    timestamp: string;
+    overallVerdict: CouncilVerdict;
+    vetoedBy: CouncilAgent[] | null;
+    memberVerdicts: CouncilMemberVerdict[];
+    unresolvedConflicts: string[];
+    /** Severity HIGH + MEDIUM from veto members */
+    requiredFixes: CouncilFinding[];
+    /** Severity LOW or from non-veto members */
+    advisoryFindings: CouncilFinding[];
+    /** Project-level advisory notes for the architect */
+    advisoryNotes: string[];
+    /** Single markdown document for final project review */
+    unifiedFeedbackMd: string;
+    /** 1-indexed */
+    roundNumber: number;
+    allCriteriaMet: boolean;
+    /** Distinct council members that produced verdicts */
+    quorumSize: number;
+    /** Path where evidence was written */
+    evidencePath: '.swarm/evidence/final-council.json';
+    /** Summary of the completed project being reviewed */
+    projectSummary: string;
+}
 export interface CouncilCriteriaItem {
     id: string;
     description: string;