opencode-swarm 7.13.2 → 7.15.0

package/dist/commands/deep-dive.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handle /swarm deep-dive command.
+ * Sanitizes scope input, parses flags, and emits a DEEP_DIVE mode signal.
+ */
+export declare function handleDeepDiveCommand(_directory: string, args: string[]): Promise<string>;

package/dist/commands/index.d.ts

@@ -14,6 +14,7 @@ export { handleConfigCommand } from './config';
 export { handleCouncilCommand } from './council';
 export { handleCurateCommand } from './curate';
 export { handleDarkMatterCommand } from './dark-matter';
+export { handleDeepDiveCommand } from './deep-dive';
 export { handleDiagnoseCommand } from './diagnose';
 export { handleDoctorCommand } from './doctor';
 export { handleEvidenceCommand, handleEvidenceSummaryCommand, } from './evidence';

package/dist/commands/registry.d.ts

@@ -293,6 +293,20 @@ export declare const COMMAND_REGISTRY: {
         readonly details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, runs 6 parallel explorer lanes (correctness, security, dependencies, docs-intent-vs-actual, tests, performance-architecture), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, synthesizes structured report. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).";
         readonly category: "agent";
     };
+    readonly 'deep-dive': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Launch deep codebase audit with parallel explorer waves, dual reviewers, and critic challenge [scope]";
+        readonly args: "<scope> [--profile standard|security|ux|architecture|full] [--max-explorers 1..8] [--json] [--skip-update] [--allow-dirty]";
+        readonly details: "Runs a read-only deep audit of the specified scope using parallel explorer waves (8-file cap per mission, ~3500 line guardrail), always 2 parallel reviewers for verification, and sequential critic challenge on HIGH/CRITICAL findings. Profiles select explorer lanes: standard (5 lanes), security, ux, architecture, full (all 8 lanes). Emits a structured findings report without mutating source code.";
+        readonly category: "agent";
+    };
+    readonly 'deep dive': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Alias for /swarm deep-dive — launch deep codebase audit";
+        readonly args: "<scope> [--profile standard|security|ux|architecture|full] [--max-explorers 1..8] [--json] [--skip-update] [--allow-dirty]";
+        readonly category: "agent";
+        readonly aliasOf: "deep-dive";
+    };
     readonly issue: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Ingest a GitHub issue into the swarm workflow [url] [--plan] [--trace] [--no-repro]";

package/dist/commands/turbo.d.ts

@@ -1,10 +1,10 @@
 /**
  * Handles the /swarm turbo command.
- * Toggles Turbo Mode on or off for the active session.
+ * Supports standard turbo toggle, lean turbo mode, and status reporting.
  *
- * @param directory - Project directory (unused but kept for consistency with other commands)
- * @param args - Optional argument: "on" | "off" | undefined (toggle behavior)
+ * @param directory - Project directory (used to persist Lean Turbo run state)
+ * @param args - Optional arguments: "lean" | "standard" | "on" | "off" | "status" | undefined
  * @param sessionID - Session ID for accessing active session state
  * @returns Feedback message about Turbo Mode state
  */
-export declare function handleTurboCommand(_directory: string, args: string[], sessionID: string): Promise<string>;
+export declare function handleTurboCommand(directory: string, args: string[], sessionID: string): Promise<string>;

package/dist/config/constants.d.ts

@@ -30,7 +30,7 @@ export declare const DEFAULT_AGENT_CONFIGS: Record<string, {
 }>;
 export declare function isQAAgent(name: string): name is QAAgentName;
 export declare function isSubagent(name: string): boolean;
-import type { ScoringConfig } from './schema';
+import type { LeanTurboConfig, ScoringConfig } from './schema';
 export declare const DEFAULT_SCORING_CONFIG: ScoringConfig;
 /**
  * Resolve scoring configuration by deep-merging user config with defaults.
@@ -75,3 +75,14 @@ export declare const COMPACTION_DEFAULTS: {
 };
 export declare const TURBO_MODE_BANNER = "## \uD83D\uDE80 TURBO MODE ACTIVE\n\n**Speed optimization enabled for this session.**\n\nWhile Turbo Mode is active:\n- **Stage A gates** (lint, imports, pre_check_batch) are still REQUIRED for ALL tasks\n- **Tier 3 tasks** (security-sensitive files matching: architect*.ts, delegation*.ts, guardrails*.ts, adversarial*.ts, sanitiz*.ts, auth*, permission*, crypto*, secret*, security) still require FULL review (Stage B)\n- **Tier 0-2 tasks** can skip Stage B (reviewer, test_engineer) to speed up execution\n- **Phase completion gates** (completion-verify and drift verification gate) are automatically bypassed \u2014 phase_complete will succeed without drift verification evidence when turbo is active. Note: turbo bypass is session-scoped; one session's turbo does not affect other sessions.\n\nClassification still determines the pipeline:\n- TIER 0 (metadata): lint + diff only \u2014 no change\n- TIER 1 (docs): Stage A + reviewer \u2014 no change\n- TIER 2 (standard code): Stage A + reviewer + test_engineer \u2014 CAN SKIP Stage B with turboMode\n- TIER 3 (critical): Stage A + 2x reviewer + 2x test_engineer \u2014 Stage B REQUIRED (no turbo bypass)\n\nDo NOT skip Stage A gates. Do NOT skip Stage B for TIER 3.\n";
 export declare const FULL_AUTO_BANNER = "## \u26A1 FULL-AUTO MODE ACTIVE\n\nYou are operating without a human in the loop. All escalations route to the Autonomous Oversight Critic instead of a user.\n\nBehavioral changes:\n- TIER 3 escalations go to the critic, not a human. Frame your questions technically, not conversationally.\n- Phase completion approval comes from the critic. Ensure all evidence is written before requesting.\n- The critic defaults to REJECT. Do not attempt to pressure, negotiate, or shortcut. Complete the evidence trail.\n- If the critic returns ESCALATE_TO_HUMAN, the session will pause or terminate. Only the critic can trigger this.\n- Do NOT ask \"Ready for Phase N+1?\" \u2014 call phase_complete directly. The critic reviews automatically.\n";
+/**
+ * Canonical default Lean Turbo configuration.
+ *
+ * This is the single source of truth for all 9 LeanTurboConfig fields.
+ * Consumers MUST reference this constant instead of hardcoding their own
+ * defaults — see v7.4.x config-drift fix (3 of 9 fields disagreed across
+ * runner.ts, lean-turbo-plan-lanes.ts, lean-turbo-status.ts, and the
+ * Zod schema in schema.ts).
+ */
+export declare const DEFAULT_LEAN_TURBO_CONFIG: LeanTurboConfig;
+export declare const LEAN_TURBO_BANNER = "## \uD83D\uDEE4\uFE0F LEAN TURBO ACTIVE\n\nLane-based parallel execution is enabled for this phase.\n\nBehavioral changes:\n- Tasks are partitioned into parallel lanes based on file-scope conflicts. Tasks in the same lane run sequentially; tasks in different lanes run concurrently (up to max_parallel_coders).\n- **Lane dispatch overrides the one-agent-per-message rule**: for lean lane dispatch only, you may send multiple Task tool calls concurrently (one per lane).\n- **Lane tasks skip per-task Stage B** (reviewer + test_engineer). Quality is enforced at phase-end via phase reviewer and critic gates instead.\n- **Degraded tasks** (global files, protected paths, high-risk patterns) and **serialized tasks** (lock-conflicted) run through standard serial workflow with full Stage B gates.\n- **Phase reviewer and critic are REQUIRED** before phase_complete when lean turbo is active \u2014 they serve as the holistic quality gate for all lane work.\n- **Full-Auto composition**: if Full-Auto is also active, lane dispatch is subject to Full-Auto delegation policy and phase approval.\n- Use the lean_turbo_run_phase tool to execute a phase with parallel lanes\n\nDo NOT skip phase reviewer/critic when configured. Degraded and serialized tasks MUST still go through full Stage B.\n";

package/dist/config/index.d.ts

@@ -18,7 +18,7 @@ export declare const _internals: {
 };
 export type { MigrationStatus, Phase, PhaseStatus, Plan, Task, TaskSize, TaskStatus, } from './plan-schema';
 export { MigrationStatusSchema, PhaseSchema, PhaseStatusSchema, PlanSchema, TaskSchema, TaskSizeSchema, TaskStatusSchema, } from './plan-schema';
-export type { AgentOverrideConfig, AutomationCapabilities, AutomationConfig, AutomationMode, PhaseCompleteConfig, PipelineConfig, PluginConfig, SwarmConfig, } from './schema';
-export { AgentOverrideConfigSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, AutomationModeSchema, PhaseCompleteConfigSchema, PipelineConfigSchema, PluginConfigSchema, SwarmConfigSchema, } from './schema';
+export type { AgentOverrideConfig, AutomationCapabilities, AutomationConfig, AutomationMode, LeanTurboConfig, PhaseCompleteConfig, PipelineConfig, PluginConfig, SwarmConfig, TurboConfig, } from './schema';
+export { AgentOverrideConfigSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, AutomationModeSchema, LeanTurboConfigSchema, PhaseCompleteConfigSchema, PipelineConfigSchema, PluginConfigSchema, SwarmConfigSchema, TurboConfigSchema, } from './schema';
 export type { DeltaSpec, Obligation, SpecDelta, SpecRequirement, SpecScenario, SpecSection, SwarmSpec, } from './spec-schema';
 export { DeltaSpecSchema, ObligationSchema, SpecDeltaSchema, SpecRequirementSchema, SpecScenarioSchema, SpecSectionSchema, SwarmSpecSchema, validateSpecContent, } from './spec-schema';

package/dist/config/schema.d.ts

@@ -735,6 +735,89 @@ export declare const ParallelizationConfigSchema: z.ZodObject<{
     max_reviewers: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type ParallelizationConfig = z.infer<typeof ParallelizationConfigSchema>;
+export declare const LeanTurboConfigSchema: z.ZodObject<{
+    max_parallel_coders: z.ZodDefault<z.ZodNumber>;
+    require_declared_scope: z.ZodDefault<z.ZodBoolean>;
+    conflict_policy: z.ZodDefault<z.ZodEnum<{
+        serialize: "serialize";
+        degrade: "degrade";
+    }>>;
+    degrade_on_risk: z.ZodDefault<z.ZodBoolean>;
+    phase_reviewer: z.ZodDefault<z.ZodBoolean>;
+    phase_critic: z.ZodDefault<z.ZodBoolean>;
+    integrated_diff_required: z.ZodDefault<z.ZodBoolean>;
+    allow_docs_only_without_reviewer: z.ZodDefault<z.ZodBoolean>;
+    worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type LeanTurboConfig = z.infer<typeof LeanTurboConfigSchema>;
+export declare const StandardTurboConfigSchema: z.ZodObject<{
+    strategy: z.ZodLiteral<"standard">;
+    lean: z.ZodOptional<z.ZodObject<{
+        max_parallel_coders: z.ZodDefault<z.ZodNumber>;
+        require_declared_scope: z.ZodDefault<z.ZodBoolean>;
+        conflict_policy: z.ZodDefault<z.ZodEnum<{
+            serialize: "serialize";
+            degrade: "degrade";
+        }>>;
+        degrade_on_risk: z.ZodDefault<z.ZodBoolean>;
+        phase_reviewer: z.ZodDefault<z.ZodBoolean>;
+        phase_critic: z.ZodDefault<z.ZodBoolean>;
+        integrated_diff_required: z.ZodDefault<z.ZodBoolean>;
+        allow_docs_only_without_reviewer: z.ZodDefault<z.ZodBoolean>;
+        worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const LeanTurboStrategyConfigSchema: z.ZodObject<{
+    strategy: z.ZodLiteral<"lean">;
+    lean: z.ZodObject<{
+        max_parallel_coders: z.ZodDefault<z.ZodNumber>;
+        require_declared_scope: z.ZodDefault<z.ZodBoolean>;
+        conflict_policy: z.ZodDefault<z.ZodEnum<{
+            serialize: "serialize";
+            degrade: "degrade";
+        }>>;
+        degrade_on_risk: z.ZodDefault<z.ZodBoolean>;
+        phase_reviewer: z.ZodDefault<z.ZodBoolean>;
+        phase_critic: z.ZodDefault<z.ZodBoolean>;
+        integrated_diff_required: z.ZodDefault<z.ZodBoolean>;
+        allow_docs_only_without_reviewer: z.ZodDefault<z.ZodBoolean>;
+        worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TurboConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    strategy: z.ZodLiteral<"standard">;
+    lean: z.ZodOptional<z.ZodObject<{
+        max_parallel_coders: z.ZodDefault<z.ZodNumber>;
+        require_declared_scope: z.ZodDefault<z.ZodBoolean>;
+        conflict_policy: z.ZodDefault<z.ZodEnum<{
+            serialize: "serialize";
+            degrade: "degrade";
+        }>>;
+        degrade_on_risk: z.ZodDefault<z.ZodBoolean>;
+        phase_reviewer: z.ZodDefault<z.ZodBoolean>;
+        phase_critic: z.ZodDefault<z.ZodBoolean>;
+        integrated_diff_required: z.ZodDefault<z.ZodBoolean>;
+        allow_docs_only_without_reviewer: z.ZodDefault<z.ZodBoolean>;
+        worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    strategy: z.ZodLiteral<"lean">;
+    lean: z.ZodObject<{
+        max_parallel_coders: z.ZodDefault<z.ZodNumber>;
+        require_declared_scope: z.ZodDefault<z.ZodBoolean>;
+        conflict_policy: z.ZodDefault<z.ZodEnum<{
+            serialize: "serialize";
+            degrade: "degrade";
+        }>>;
+        degrade_on_risk: z.ZodDefault<z.ZodBoolean>;
+        phase_reviewer: z.ZodDefault<z.ZodBoolean>;
+        phase_critic: z.ZodDefault<z.ZodBoolean>;
+        integrated_diff_required: z.ZodDefault<z.ZodBoolean>;
+        allow_docs_only_without_reviewer: z.ZodDefault<z.ZodBoolean>;
+        worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "strategy">;
+export type TurboConfig = z.infer<typeof TurboConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
@@ -1206,6 +1289,39 @@ export declare const PluginConfigSchema: z.ZodObject<{
         max_coders: z.ZodDefault<z.ZodNumber>;
         max_reviewers: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    turbo: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        strategy: z.ZodLiteral<"standard">;
+        lean: z.ZodOptional<z.ZodObject<{
+            max_parallel_coders: z.ZodDefault<z.ZodNumber>;
+            require_declared_scope: z.ZodDefault<z.ZodBoolean>;
+            conflict_policy: z.ZodDefault<z.ZodEnum<{
+                serialize: "serialize";
+                degrade: "degrade";
+            }>>;
+            degrade_on_risk: z.ZodDefault<z.ZodBoolean>;
+            phase_reviewer: z.ZodDefault<z.ZodBoolean>;
+            phase_critic: z.ZodDefault<z.ZodBoolean>;
+            integrated_diff_required: z.ZodDefault<z.ZodBoolean>;
+            allow_docs_only_without_reviewer: z.ZodDefault<z.ZodBoolean>;
+            worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        strategy: z.ZodLiteral<"lean">;
+        lean: z.ZodObject<{
+            max_parallel_coders: z.ZodDefault<z.ZodNumber>;
+            require_declared_scope: z.ZodDefault<z.ZodBoolean>;
+            conflict_policy: z.ZodDefault<z.ZodEnum<{
+                serialize: "serialize";
+                degrade: "degrade";
+            }>>;
+            degrade_on_risk: z.ZodDefault<z.ZodBoolean>;
+            phase_reviewer: z.ZodDefault<z.ZodBoolean>;
+            phase_critic: z.ZodDefault<z.ZodBoolean>;
+            integrated_diff_required: z.ZodDefault<z.ZodBoolean>;
+            allow_docs_only_without_reviewer: z.ZodDefault<z.ZodBoolean>;
+            worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "strategy">>;
     turbo_mode: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     quiet: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     version_check: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;