opencode-swarm 7.188.12 → 7.190.0

package/dist/cli/{speckit-checkoff-d3v522cb.js → speckit-checkoff-k5jm0abh.js}

@@ -7,14 +7,14 @@ import {
   parseSpeckitTasksContent,
   propagateSpeckitCheckoff,
   writeSpeckitCheckoffLedger
-} from "./index-yjjyapbf.js";
+} from "./index-xyvrfram.js";
 import"./index-ejhxgyvm.js";
 import"./index-7g4c7s5r.js";
-import"./index-p2tqzwh6.js";
-import"./index-1krdj1sc.js";
+import"./index-qs9myayh.js";
+import"./index-ejk34dnw.js";
 import"./index-zxdawwc7.js";
-import"./index-2h13hjbf.js";
-import"./index-zfbxfm2m.js";
+import"./index-t0gj8s46.js";
+import"./index-s8b67e6h.js";
 import"./index-bk5tah7q.js";
 import"./index-gknz3bv1.js";
 import"./index-zpsr8rpc.js";

package/dist/cli/{telemetry-kvhe94gs.js → telemetry-9szfdfqv.js}

@@ -14,7 +14,7 @@ import {
   startHeartbeatTracking,
   stopHeartbeatTracking,
   telemetry
-} from "./index-d3rjvm9e.js";
+} from "./index-7vnr5cmp.js";
 import"./index-fzpt2djt.js";
 import"./index-gknz3bv1.js";
 import"./index-zpsr8rpc.js";

package/dist/cli/{workspace-snapshot-30kdf018.js → workspace-snapshot-9f12p1s1.js}

@@ -46,11 +46,11 @@ import {
   shouldSkipSnapshot,
   switchPrFeedbackTrackingCandidateAsync,
   workspaceSnapshotMatches
-} from "./index-kaqdzhj3.js";
-import"./index-7hr5m7yp.js";
+} from "./index-kfevm0n5.js";
+import"./index-nkgzkt7c.js";
 import"./index-2s7dvzff.js";
 import"./index-fzpt2djt.js";
-import"./index-p2tqzwh6.js";
+import"./index-qs9myayh.js";
 import"./index-zxdawwc7.js";
 import"./index-zpsr8rpc.js";
 import"./index-zgwm4ryv.js";

package/dist/cli/{worktree-collision-ownership-yy1tp8t9.js → worktree-collision-ownership-3wwfc72t.js}

@@ -6,37 +6,37 @@ import {
   WORKTREE_PROVISIONING_OWNER_LEASE_MS,
   removeWorktreeProvisioningOwner,
   scanWorktreeProvisioningOwnersForRecovery
-} from "./index-f6exny9m.js";
+} from "./index-n8q43eff.js";
 import {
   scanWorktreeMergeFailuresForRecovery
-} from "./index-zsrtt42s.js";
+} from "./index-v3bmwmqw.js";
 import {
   scanDelegationFallbacksForRecovery,
   scanDelegationsForRecovery
-} from "./index-8jy605yf.js";
-import"./index-7hr5m7yp.js";
+} from "./index-npe10823.js";
+import"./index-nkgzkt7c.js";
 import"./index-2s7dvzff.js";
-import"./index-x1eh2636.js";
-import"./index-ntda6tje.js";
-import"./index-9tvjwv01.js";
+import"./index-mcv0v2dp.js";
+import"./index-feaxsjrt.js";
+import"./index-2fpv2wmc.js";
 import"./index-ry16d01s.js";
 import"./index-rdm3px0g.js";
 import"./index-7pmbnjvj.js";
-import"./index-1xa8wq76.js";
-import"./index-tmn4pf7q.js";
+import"./index-z3ahy9c2.js";
+import"./index-mp1s7b0n.js";
 import"./index-vzm6zre7.js";
 import"./index-ae75rja9.js";
-import"./index-8q8783g0.js";
-import"./index-hh7pa3yk.js";
-import"./index-twb3f4tk.js";
+import"./index-3zwhxk98.js";
+import"./index-r9yvpr2m.js";
+import"./index-8bx6vhzk.js";
 import"./index-t7hmqgjy.js";
-import"./index-d3rjvm9e.js";
+import"./index-7vnr5cmp.js";
 import {
   canonicalRootKeyFresh
 } from "./index-fzpt2djt.js";
 import"./index-ejhxgyvm.js";
 import"./index-7g4c7s5r.js";
-import"./index-p2tqzwh6.js";
+import"./index-qs9myayh.js";
 import"./index-zxdawwc7.js";
 import"./index-bk5tah7q.js";
 import"./index-gknz3bv1.js";

package/dist/cli/{worktree-isolation-e56skbfw.js → worktree-isolation-zfk7zk6a.js}

@@ -18,80 +18,81 @@ import {
   preserveDirtyWorktreeForCallId,
   readLaneEnvFileFromDisk,
   resetStandardWorktreeIsolationState,
+  runSerializedWithMergeBacks,
   sanitizeWorktreeTaskId,
   standardWorktreeByCallID,
   standardWorktreeSerializationSessions
-} from "./index-94fgbb34.js";
-import"./index-9sps637v.js";
-import"./index-5cksakjf.js";
-import"./index-84pwb6cz.js";
+} from "./index-ffgcdf49.js";
+import"./index-9xxqdzp4.js";
+import"./index-tkhenmms.js";
+import"./index-9gcqmgbc.js";
 import"./index-j2vv0h13.js";
-import"./index-k8sarme1.js";
-import"./index-8xabhfwr.js";
+import"./index-y9v41185.js";
+import"./index-b2j231jy.js";
 import"./index-txdagbh7.js";
-import"./index-xy2403g9.js";
+import"./index-ajzgeb2s.js";
 import"./index-rdec0y3z.js";
-import"./index-e638qt2d.js";
-import"./index-w9tfb0am.js";
-import"./index-m3hhaf61.js";
-import"./index-19yt5p2t.js";
-import"./index-kaqdzhj3.js";
-import"./index-9czp2dcg.js";
+import"./index-0qc7a88d.js";
+import"./index-vhn4e6rm.js";
+import"./index-s92a5ta3.js";
+import"./index-dmq7p8s9.js";
+import"./index-kfevm0n5.js";
+import"./index-mjfpaxw3.js";
 import"./index-cjapb4hy.js";
-import"./index-f6exny9m.js";
+import"./index-n8q43eff.js";
 import"./index-pt7h91zc.js";
 import"./index-q7sjgr1y.js";
-import"./index-f0jn2nvs.js";
-import"./index-tbyvvq50.js";
+import"./index-mseerehd.js";
+import"./index-fb5s32c2.js";
 import"./index-6b295cas.js";
 import"./index-9nyqt3kb.js";
-import"./index-yc0y5fjt.js";
-import"./index-zsrtt42s.js";
-import"./index-yjjyapbf.js";
-import"./index-5pafc9x6.js";
-import"./index-7z2pxxye.js";
+import"./index-p69k8v0e.js";
+import"./index-v3bmwmqw.js";
+import"./index-xyvrfram.js";
+import"./index-69tgdm9t.js";
+import"./index-zyg1m9d0.js";
 import"./index-g4fs6z4e.js";
-import"./index-8jy605yf.js";
-import"./index-fhtcx5ag.js";
-import"./index-0b172h6r.js";
+import"./index-npe10823.js";
+import"./index-h0xhec3d.js";
+import"./index-49e65y51.js";
 import"./index-m9zzj4ee.js";
-import"./index-7hr5m7yp.js";
+import"./index-nkgzkt7c.js";
 import"./index-2s7dvzff.js";
-import"./index-jgr1rsr1.js";
-import"./index-q9kefh33.js";
+import"./index-2kpqqcch.js";
+import"./index-sxj143a4.js";
 import"./index-rtry5xyf.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-kap0d52p.js";
+} from "./index-1s95jrgc.js";
 import"./index-pkhbd2t5.js";
 import"./index-0725jpp7.js";
-import"./index-qha2p47y.js";
-import"./index-95pzyv9a.js";
-import"./index-wrdktgpy.js";
-import"./index-x1eh2636.js";
-import"./index-ntda6tje.js";
-import"./index-9tvjwv01.js";
+import"./index-rgkzcw2a.js";
+import"./index-ej1hdw16.js";
+import"./index-zk6ttjkt.js";
+import"./index-mcv0v2dp.js";
+import"./index-feaxsjrt.js";
+import"./index-2fpv2wmc.js";
 import"./index-ry16d01s.js";
 import"./index-rdm3px0g.js";
 import"./index-7pmbnjvj.js";
-import"./index-1xa8wq76.js";
-import"./index-tmn4pf7q.js";
+import"./index-z3ahy9c2.js";
+import"./index-mp1s7b0n.js";
 import"./index-vzm6zre7.js";
 import"./index-ae75rja9.js";
-import"./index-8q8783g0.js";
-import"./index-hh7pa3yk.js";
-import"./index-twb3f4tk.js";
+import"./index-3zwhxk98.js";
+import"./index-r9yvpr2m.js";
+import"./index-8bx6vhzk.js";
 import"./index-t7hmqgjy.js";
-import"./index-d3rjvm9e.js";
+import"./index-7vnr5cmp.js";
 import"./index-fzpt2djt.js";
 import"./index-ejhxgyvm.js";
 import"./index-7g4c7s5r.js";
-import"./index-p2tqzwh6.js";
+import"./index-qs9myayh.js";
 import"./index-gx2vp8gx.js";
-import"./index-1krdj1sc.js";
+import"./index-ejk34dnw.js";
 import"./index-zxdawwc7.js";
-import"./index-2h13hjbf.js";
-import"./index-zfbxfm2m.js";
+import"./index-t0gj8s46.js";
+import"./index-s8b67e6h.js";
 import"./index-bk5tah7q.js";
 import"./index-gknz3bv1.js";
 import"./index-zpsr8rpc.js";
@@ -103,6 +104,7 @@ export {
   standardWorktreeSerializationSessions,
   standardWorktreeByCallID,
   sanitizeWorktreeTaskId,
+  runSerializedWithMergeBacks,
   resolveWorktreeIsolationConfig,
   resetStandardWorktreeIsolationState,
   readLaneEnvFileFromDisk,

package/dist/commands/coupling.d.ts

@@ -7,9 +7,13 @@
  * a structured JSON report under `.swarm/epic/coupling-report.json` for
  * programmatic consumption.
  *
- * This command always runs independent of `turbo.epic.cochange.enabled`. The
- * config flag gates runtime planner integration (M3); `/swarm coupling` is a
- * diagnostic and what-if tool, so users can see the report before opting in.
+ * The report itself always runs (it is a diagnostic), but the co-change
+ * signal honors the `epic.cochange.enabled` master gate (default
+ * false): when it is not `true`, no git history is scanned, `p` reflects
+ * declared-path conflicts only, and the report states that the co-change
+ * signal is disabled by config (`cochangeSignal: 'disabled-by-config'` in
+ * JSON output). Declared task scopes resolve from the authoritative v2
+ * scope-binding store (what `declare_scope` writes), then `files_touched`.
  *
  * Flags:
  *   --phase <n>             Scope to one phase (default: whole plan).
@@ -17,9 +21,18 @@
  *   --min-co-changes <n>    Co-change-count floor override (default: 5).
  *   --format <fmt>          'markdown' (default) or 'json'.
  *   --persist               Also write JSON to .swarm/epic/coupling-report.json.
+ *   --suggest               Also shape the whole plan (Epic v2 C7): the same
+ *                           ranked advisory `save_plan` returns as
+ *                           `epic_shaping` (`src/epic/shaping.ts`), with
+ *                           the start's inputs (live declared scopes, learned
+ *                           signals of the project prior, co-change when
+ *                           enabled, the epic's wave width). Read-only.
  */
+import { loadPluginConfigWithMeta } from '../config/index.js';
+import { getCoChangeData, getCoChangePairs } from '../epic/cochange-source.js';
+import { loadEpicLearningView } from '../epic/learning-store.js';
+import { isGitRepo } from '../git/branch.js';
 import { loadPlanJsonOnly } from '../plan/manager.js';
-import { getCoChangePairs } from '../turbo/epic/cochange-source.js';
 /**
  * Entry point invoked from the command registry. Returns the report
  * formatted per the `--format` flag, plus a one-line "wrote to ..." trailer
@@ -33,4 +46,8 @@ export declare function handleCouplingCommand(directory: string, args: string[])
 export declare const _internals: {
     loadPlanJsonOnly: typeof loadPlanJsonOnly;
     getCoChangePairs: typeof getCoChangePairs;
+    getCoChangeData: typeof getCoChangeData;
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+    loadEpicLearningView: typeof loadEpicLearningView;
+    isGitRepo: typeof isGitRepo;
 };

package/dist/commands/epic-learning.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `/swarm epic learning` and `/swarm epic prior [show|reset]` (Epic v2 C6)
+ * — read-only views of what epics learned, and the one destructive action
+ * (`prior reset`, two-step through the shared destructive-confirm
+ * primitive: preview + token, then `--confirm=<token>`). See
+ * `src/epic/learning.ts` (the model) and
+ * `src/epic/learning-store.ts` (prior + posterior). Both work
+ * regardless of the Epic config gate, like `status` and `close`.
+ */
+import { type EpicLearningSettings } from '../epic/learning.js';
+import { loadEpicLearningView, readEpicPrior, resetEpicPrior } from '../epic/learning-store.js';
+import { getOpenEpic } from '../epic/lifecycle.js';
+import { consumeConfirmToken, issueConfirmToken } from './destructive-purge.js';
+/** DI seam (AGENTS.md invariant 7). Restore in `afterEach`. */
+export declare const _internals: {
+    getOpenEpic: typeof getOpenEpic;
+    issueConfirmToken: typeof issueConfirmToken;
+    consumeConfirmToken: typeof consumeConfirmToken;
+    loadEpicLearningView: typeof loadEpicLearningView;
+    readEpicPrior: typeof readEpicPrior;
+    resetEpicPrior: typeof resetEpicPrior;
+    now: () => number;
+};
+export declare const EPIC_PRIOR_USAGE = "Usage: /swarm epic prior [show] | /swarm epic prior reset [--confirm=<token>]";
+/** `/swarm epic learning` — what the Epic planner learned and uses now. */
+export declare function renderEpicLearning(directory: string, settings: EpicLearningSettings): string;
+/** `/swarm epic prior [show|reset [--confirm=<token>]]`. */
+export declare function renderEpicPrior(directory: string, args: string[], settings: EpicLearningSettings): string;

package/dist/commands/epic.d.ts

@@ -1,32 +1,60 @@
 /**
- * `/swarm epic` — Epic Mode activation toggle and diagnostics (Capability C).
+ * `/swarm epic` — plan-scoped Epic lifecycle and diagnostics (Epic v2 C1a).
  *
  * Subcommands:
- *   /swarm epic on        — enable Epic Mode for this session
- *   /swarm epic off       — disable Epic Mode for this session
- *   /swarm epic           — toggle (on if off, off if on)
- *   /swarm epic status    — show current state + last decision rationale
- *   /swarm epic decide    — run the activation decision once and print the
- *                            verdict without dispatching execution
- *                            (read-only what-if; does NOT write to
- *                             `.swarm/evidence/epic-promotions.jsonl`)
+ *   /swarm epic start [--force] — open an epic for the current plan (see
+ *                            `src/epic/start.ts` for the refusals)
+ *   /swarm epic close [--abandon] [--land squash|merge|none]
+ *                          — close the open epic, land its epic branch onto
+ *                            the original branch (default squash: staged,
+ *                            uncommitted), and write its close report
+ *   /swarm epic           — same as `status` (the bare form never mutates
+ *                            the epic)
+ *   /swarm epic status [--repair-refs]
+ *                          — lifecycle state, orphan detection, sentinel/row
+ *                            repair, recorded worktree merge failures, and
+ *                            the one-time retirement of Epic v1 session state
+ *                            (including the epic's waves, phases, the
+ *                            phase's task components recorded with the
+ *                            latest wave, and divergence recorded by
+ *                            `epic_next_wave`);
+ *                            `--repair-refs` re-adopts task commits a rebase
+ *                            or amend made unreachable (Epic v2 C3)
+ *   /swarm epic report [<key>|last] [--format json]
+ *                          — the epic scorecard (Epic v2 C8): live for the
+ *                            open epic, else from a past epic's close report
+ *                            in `.swarm/epic-prior/reports/` (`last` = the
+ *                            newest; `<key>` = a report or epic key)
+ *   /swarm epic learning   — what the Epic planner learned (hot files,
+ *                            learned co-writes) and uses now (Epic v2 C6)
+ *   /swarm epic prior [show|reset [--confirm=<token>]]
+ *                          — the project prior `.swarm/epic-prior/
+ *                            learning.json`; `reset` previews without
+ *                            `--confirm`
+ *   /swarm epic clear-merge-failure <taskId> [--confirm]
+ *                          — clear a recorded worktree merge failure that
+ *                            blocks an epic wave (read-only without --confirm)
  *
- * Toggling only mutates session state (and the durable
- * `.swarm/epic-state.json`); it does not start or stop any execution. The
- * `epic_decide_phase` + `epic_plan_waves` tools (plus per-wave Task dispatch
- * by the architect) are the architect-facing entries that gate execution.
+ * The Epic v1 `on` / `off` per-session toggles were removed: an epic is
+ * bound to one plan and every Epic behaviour is driven by the sentinel-first
+ * project probe (`isEpicOpenForProject`). `decide` / `last` were removed in
+ * Epic v2 C2 with the activation gate: `epic_next_wave` plans every wave and
+ * `status` shows what it recorded. `calibration` was renamed `learning` in
+ * Epic v2 C6 (the v1 self-calibration was replaced). `close`, `status`,
+ * `report`, `learning`, and `prior` work regardless of the config gate.
  */
 import { loadPluginConfigWithMeta } from '../config/index.js';
-import { isGitRepo } from '../git/branch.js';
+import { closeEpic } from '../epic/close.js';
+import { checkEpicBranch } from '../epic/epic-branch.js';
+import { retireLegacyEpicSessionState } from '../epic/legacy-migration.js';
+import { type EpicLandMode, getOpenEpic, inspectEpic, repairEpicSentinel, updateEpicRecord } from '../epic/lifecycle.js';
+import { planEpicTaskRefRepair, readEpicRefs, syncEpicRefs, writeEpicRef } from '../epic/markers.js';
+import { clearMergeFailureCommand, describeMergeFailuresForStatus } from '../epic/merge-epoch.js';
+import { completedBeforeEpic } from '../epic/next-wave.js';
+import { resolvePlanMarkerScope } from '../epic/plan-key.js';
+import { selectEpicReport } from '../epic/report.js';
+import { startEpic } from '../epic/start.js';
 import { loadPlanJsonOnly } from '../plan/manager.js';
-import { ensureAgentSession } from '../state.js';
-import { decideEpicActivation } from '../turbo/epic/activation.js';
-import { isCalibrationStateUnreadable, loadCalibrationState } from '../turbo/epic/calibration.js';
-import { getCoChangeData } from '../turbo/epic/cochange-source.js';
-import { readDivergenceHistory } from '../turbo/epic/divergence-recorder.js';
-import { readPromotionEvidence } from '../turbo/epic/promotion-evidence.js';
-import { disableEpicMode, enableEpicMode, isEpicModeActive, isStateUnreadable, loadEpicSessionState } from '../turbo/epic/state.js';
-import { readTaskScopes } from '../turbo/lean/conflicts.js';
 /**
  * Test-only DI seam. Production code calls `_internals.fn(...)` so tests can
  * replace these without `mock.module` (AGENTS.md invariant 7).
@@ -34,19 +62,36 @@ import { readTaskScopes } from '../turbo/lean/conflicts.js';
 export declare const _internals: {
     loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
     loadPlanJsonOnly: typeof loadPlanJsonOnly;
-    getCoChangeData: typeof getCoChangeData;
-    decideEpicActivation: typeof decideEpicActivation;
-    ensureAgentSession: typeof ensureAgentSession;
-    isEpicModeActive: typeof isEpicModeActive;
-    isStateUnreadable: typeof isStateUnreadable;
-    loadEpicSessionState: typeof loadEpicSessionState;
-    enableEpicMode: typeof enableEpicMode;
-    disableEpicMode: typeof disableEpicMode;
-    readTaskScopes: typeof readTaskScopes;
-    readPromotionEvidence: typeof readPromotionEvidence;
-    loadCalibrationState: typeof loadCalibrationState;
-    isCalibrationStateUnreadable: typeof isCalibrationStateUnreadable;
-    readDivergenceHistory: typeof readDivergenceHistory;
-    isGitRepo: typeof isGitRepo;
+    resolvePlanMarkerScope: typeof resolvePlanMarkerScope;
+    describeMergeFailuresForStatus: typeof describeMergeFailuresForStatus;
+    clearMergeFailureCommand: typeof clearMergeFailureCommand;
+    startEpic: typeof startEpic;
+    closeEpic: typeof closeEpic;
+    inspectEpic: typeof inspectEpic;
+    repairEpicSentinel: typeof repairEpicSentinel;
+    retireLegacyEpicSessionState: typeof retireLegacyEpicSessionState;
+    checkEpicBranch: typeof checkEpicBranch;
+    getOpenEpic: typeof getOpenEpic;
+    updateEpicRecord: typeof updateEpicRecord;
+    planEpicTaskRefRepair: typeof planEpicTaskRefRepair;
+    syncEpicRefs: typeof syncEpicRefs;
+    readEpicRefs: typeof readEpicRefs;
+    writeEpicRef: typeof writeEpicRef;
+    completedBeforeEpic: typeof completedBeforeEpic;
+    selectEpicReport: typeof selectEpicReport;
 };
 export declare function handleEpicCommand(directory: string, args: string[], sessionID: string): Promise<string>;
+/** Parse `report` options: one optional selector, `--format json|markdown`. */
+export declare function parseReportOptions(args: string[]): {
+    selector: string | null;
+    format: 'markdown' | 'json';
+} | {
+    error: string;
+};
+/** Parse `close` options: `--abandon`, `--land <mode>` / `--land=<mode>`. */
+export declare function parseCloseOptions(args: string[]): {
+    abandon: boolean;
+    land?: EpicLandMode;
+} | {
+    error: string;
+};

package/dist/commands/registry.d.ts

@@ -707,16 +707,16 @@ export declare const COMMAND_REGISTRY: {
     readonly coupling: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Measure plan coupling (p) and rank modules driving conflicts (Epic mode preview)";
-        readonly details: "Computes the coupling coefficient p = (conflicting task pairs) / (total task pairs) over the current plan, using Epic mode's combined path + co-change conflict signal. Surfaces per-module contention and a ranked decoupling roadmap. Read-only: runs independent of `turbo.epic.cochange.enabled` so it can be used as a what-if diagnostic before opting into the runtime signal.";
-        readonly args: "--phase <n>, --threshold <-1..1>, --min-co-changes <n>, --format markdown|json, --persist";
+        readonly details: "Computes the coupling coefficient p = (conflicting task pairs) / (total task pairs) over the current plan, using Epic mode's combined path + co-change conflict signal. Surfaces per-module contention and a ranked decoupling roadmap. Declared scopes come from live `declare_scope` bindings (falling back to plan `files_touched`). Read-only and usable without Epic Mode on, but the co-change signal is included only when `epic.cochange.enabled` is true — otherwise p reflects path conflicts only and the report says the signal is disabled by config. `--suggest` adds Epic plan shaping for the whole plan (the advisory save_plan returns as `epic_shaping` when Epic is on): the plan's epic sizing and up to 5 suggestions — scope advice (declare-scope, narrow-scope) first, then by their effective-speedup gain: extract-prerequisite, isolate-hot-file, split-task, merge-tasks, each with a concrete save_plan patch. Read-only; bounded by a work budget (skipped-budget beyond it).";
+        readonly args: "--phase <n>, --threshold <-1..1>, --min-co-changes <n>, --format markdown|json, --persist, --suggest";
         readonly category: "diagnostics";
         readonly toolPolicy: "none";
     };
     readonly epic: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
-        readonly description: "Toggle Epic Mode (autonomous coupling-aware parallel activation) and inspect its decisions";
-        readonly details: "Epic Mode is an additive overlay that composes Lean Turbo. When on, the architect follows the transparent decide-then-dispatch wave flow: declare_scope (per pending task) → epic_decide_phase → epic_plan_waves → for each wave in order, dispatch one Task per taskId in the wave, ALL in one assistant message (each concurrent coder appears as a visible subagent the user can click into) → epic_record_divergence. epic_decide_phase computes the plan-wide coupling coefficient p and gates parallel promotion on p + a hot-module check + a greenfield rule. epic_plan_waves partitions promoted phases into ordered concurrent groups (waves) that respect dependency order and scope disjointness. Subcommands: on, off, status, decide (read-only what-if), last (most recent decision from durable evidence log), calibration (Capability D state: learned threshold + hot modules + recent divergent tasks). Bare /swarm epic shows status. Decision rationale persists to .swarm/evidence/epic-promotions.jsonl after every epic_decide_phase invocation.";
-        readonly args: "on | off | status | decide | last | calibration";
+        readonly description: "Open, inspect, and close a plan-scoped epic (coupling-aware parallel execution of the current plan)";
+        readonly details: "An epic is bound to ONE plan: `start` opens it for the current plan, `close` ends it. Requires `epic.mode.enabled: true` in config (top-level `epic` block; no `turbo` block needed — the legacy `turbo.epic` path is still accepted and migrated). `start [--force]` refuses, in order: epic-disabled-by-config, host-unsupported (the host gives the plugin no OpenCode SDK client — OpenCode 2 does not yet — so worktree-isolated coders and the phase review cannot run), no-plan / plan-ledger-unreadable, epic-already-open (idempotent for the same plan) / epic-open-for-other-plan, turbo-active (config turbo_mode, a session with Turbo on, or a running Lean run — Epic enables neither Lean nor Turbo and never waives per-task QA), dirty-baseline (git: uncommitted changes outside .swarm/), detached-head / epic-branch-exists (epic-branch policy), in-flight-coders (any coder dispatch, background delegation, unsettled settlement, or preserved/recovery lane), not-epic-sized (too few pending tasks, insufficient scope coverage, or insufficient effective speedup — run it in Balanced, or reshape it with the plan-shaping suggestions shown; `--force` overrides and is recorded). Non-git projects run an epic serially (one task per wave). Git epics default to `epic.commit_policy: \"epic-branch\"`: start checks out `swarm/epic/<epicKey>` and every Epic commit goes there (epic_next_wave blocks with epic-branch-mismatch, and no landing or residue is committed, while HEAD is elsewhere); `current-branch` keeps commits on the starting branch. In a git epic every coder runs in an isolated worktree (refused EPIC_ISOLATION_DEGRADED when isolation is unavailable) and lands as a `swarm(task <id>): …` merge commit; main-tree files a non-coder writer (test_engineer, docs) wrote for a task are committed as residue of that task; update_task_status writes nothing to git; wave close records the commit of each task as `refs/swarm/epics/<epicKey>/tasks/<id>` (deleted at close unless `epic.retain_refs`; never pushed by default). While open, the architect calls epic_next_wave and does what its status says: it issues one wave at a time (tasks with non-conflicting declared scopes — exclusive tasks alone, at most one task per densely coupled component; phases strictly in order), the architect dispatches one Task per taskId in ONE message and runs per-task QA (pre_check_batch → reviewer + test_engineer → update_task_status(completed)), and the next epic_next_wave closes the wave (recording outcomes and declared-vs-actual divergence) and issues the next; when a phase is done it returns phase-ready-for-review → epic_phase_review → phase_complete. `close [--abandon] [--land squash|merge|none]` refuses while tasks are pending (or the epic is orphaned / unreadable) unless `--abandon`, refuses a dirty tree before landing, writes a close report (epic-report-v2, embedding the epic scorecard) to .swarm/epic/reports/ and .swarm/epic-prior/reports/ (newest 50 kept), and lands the epic branch onto the original branch: squash (default — staged, uncommitted changes for you to review and commit), merge (a --no-ff merge commit), or none (switch back only). The epic branch is kept (remove it with `git branch -D` once committed). A landing conflict is rolled back (the attempted squash or merge is undone) and the epic stays closing — rerun close to resume. `--abandon` never lands; it switches back to the original branch when the tree is clean. `status [--repair-refs]` (also bare /swarm epic) shows the epic, its waves, phases, the task components recorded with the latest wave and recorded divergence, orphan detection (plan renamed or replaced), sentinel/row repair, recorded worktree merge failures, and retires legacy Epic v1 session state once; `--repair-refs` re-adopts task commits a rebase or amend made unreachable from HEAD. `report [<key>|last] [--format json]` shows the epic scorecard: live for the open epic (bare `report`), else from the close report of a past epic in .swarm/epic-prior/reports/ (`last` = newest; `<key>` = a report or epic key) — tasks completed in the epic, waves (count, width), time over closed waves (wave span, task issue→resolve time, and their ratio, a concurrency factor that is NOT a speedup: it includes queueing behind serialized QA), conflicts (merge-back failures, undeclared writes), rework (extra generations, reopens), first-pass gate rates (upper bounds: the failure history is bounded), forced/sizing at start and learned hot files. Epics learn from their outcomes: undeclared writes teach learned co-writes (a task declaring D that also wrote f makes later tasks declaring D conflict with tasks on f — planner analysis only, never write authorization) and incidents (undeclared writes, merge conflicts, Stage B failures, rework, reopens) in excess of clean exposures make a file hot (a task declaring it runs alone) — undeclared writes its strongest learned co-writer explains are discounted (expansion already separates them), so one declarer writing a file is not heat; an empty history learns nothing (neutral start). Each wave close updates the posterior of the epic; close merges it into the project prior .swarm/epic-prior/learning.json (decayed per epic and by age; kept across /swarm close; `epic.learning.*`). `learning` shows what the planner learned and uses now; `prior [show]` shows the project prior; `prior reset` previews and prints a single-use confirm token (15 minutes); `prior reset --confirm=<token>` clears it. Also: clear-merge-failure <taskId> [--confirm]. The former `on` / `off` toggles, the `decide` / `last` subcommands and `calibration` (renamed `learning`) were removed.";
+        readonly args: "start [--force] | close [--abandon] [--land squash|merge|none] | status [--repair-refs] | report [<key>|last] [--format json] | learning | prior [show|reset [--confirm=<token>]] | clear-merge-failure <taskId> [--confirm]";
         readonly category: "diagnostics";
         readonly toolPolicy: "none";
     };
@@ -730,7 +730,7 @@ export declare const COMMAND_REGISTRY: {
     readonly finalize: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Use /swarm finalize to finalize the swarm project and archive evidence";
-        readonly details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs aggressive git reset --hard to the default remote branch, discarding uncommitted changes and gitignored build artifacts (user-created untracked files are preserved); falls back to a cautious reset that preserves uncommitted changes when the aggressive path cannot proceed. Alignment re-verifies the tracked tree immediately before its destructive reset and aborts fail-closed (leaving alignment undone) when tracked files changed after the close gate was verified or the status cannot be re-read (#2953). WARNING: alignment discards local changes and gitignored files. Resets agent sessions, delegation chains, and active-agent mappings. Reads .swarm/close-lessons.md for explicit lessons and runs curation. Cleanup: knowledge.jsonl is preserved; plan.json, plan.md, events.jsonl, handoff.*, run-memory.jsonl, and summaries/ are removed. Use --skill-review to run the quota-bounded skill_improver in proposal mode. Use --dry-run to preview what finalize would archive, clean, and align without taking the lock or changing anything.";
+        readonly details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs aggressive git reset --hard to the default remote branch, discarding uncommitted changes and gitignored build artifacts (user-created untracked files are preserved); falls back to a cautious reset that preserves uncommitted changes when the aggressive path cannot proceed. Alignment re-verifies the tracked tree immediately before its destructive reset and aborts fail-closed (leaving alignment undone) when tracked files changed after the close gate was verified or the status cannot be re-read (#2953). WARNING: alignment discards local changes and gitignored files. Resets agent sessions, delegation chains, and active-agent mappings. Reads .swarm/close-lessons.md for explicit lessons and runs curation. Cleanup: knowledge.jsonl is preserved; plan.json, plan.md, events.jsonl, handoff.*, run-memory.jsonl, and summaries/ are removed. An open epic (Epic Mode) is first closed as abandoned-by-swarm-close (it never lands; its close report is archived); .swarm/epic/ is cleaned, while .swarm/epic-prior/ (learning prior and past epic reports) is preserved. Use --skill-review to run the quota-bounded skill_improver in proposal mode. Use --dry-run to preview what finalize would archive, clean, and align without taking the lock or changing anything.";
         readonly args: "--prune-branches, --skill-review, --dry-run";
         readonly category: "core";
         readonly toolPolicy: "none";
@@ -1116,8 +1116,8 @@ export declare const COMMAND_REGISTRY: {
     };
     readonly turbo: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
-        readonly description: "Toggle Turbo Mode strategy for the active session [on|off|lean|standard|epic|status]";
-        readonly args: "on, off, lean, standard, epic, status";
+        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 toolPolicy: "none";

package/dist/commands/turbo.d.ts

@@ -1,4 +1,5 @@
 import { loadPluginConfigWithMeta } from '../config';
+import { isEpicOpenForProject } from '../epic/lifecycle';
 /**
  * Test-only dependency-injection seam. Production code calls
  * `_internals.loadPluginConfigWithMeta(...)` so tests can replace the function
@@ -8,13 +9,27 @@ import { loadPluginConfigWithMeta } from '../config';
  */
 export declare const _internals: {
     loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+    isEpicOpenForProject: typeof isEpicOpenForProject;
 };
+/**
+ * Reply to `/swarm turbo epic [on|off]` and bare `/swarm turbo epic`. Epic
+ * Mode is no longer a Turbo strategy: it is started with `/swarm epic start`
+ * and never enables Lean or Turbo. The redirect changes no state.
+ */
+export declare const TURBO_EPIC_REDIRECT_MESSAGE = "Epic is no longer combined with Turbo; use `/swarm epic start` (it enables neither Lean nor Turbo, and per-task QA is never waived). Turbo state is unchanged.";
+/**
+ * Reply to any Turbo-enabling invocation while an Epic is open for the
+ * project: Turbo/Lean would waive per-task QA (Stage B) that Epic never
+ * waives, so enabling is refused until the Epic is closed. Disabling Turbo
+ * stays available.
+ */
+export declare const TURBO_EPIC_OPEN_REFUSAL = "Turbo Mode NOT enabled \u2014 epic-open: close the epic first (/swarm epic close). Turbo state is unchanged.";
 /**
  * Handles the /swarm turbo command.
  * Supports standard turbo toggle, lean turbo mode, and status reporting.
  *
  * @param directory - Project directory (used to persist Lean Turbo run state)
- * @param args - Arguments: (none) | "on" | "off" | "status" | "lean" ["on"|"off"] | "standard" ["on"|"off"] | "epic" ["on"|"off"]. Unknown arguments are rejected without changing state.
+ * @param args - Arguments: (none) | "on" | "off" | "status" | "lean" ["on"|"off"] | "standard" ["on"|"off"]. "epic" ["on"|"off"] is refused with a redirect to `/swarm epic start`; every Turbo-enabling argument is refused while an Epic is open for the project. Unknown arguments are rejected without changing state.
  * @param sessionID - Session ID for accessing active session state
  * @returns Feedback message about Turbo Mode state
  */

package/dist/config/constants.d.ts

@@ -28,6 +28,16 @@ export declare const GENERAL_COUNCIL_TOOL_NAMES: readonly ["convene_general_coun
 export declare const GENERAL_COUNCIL_AGENT_TOOL_MAP: Partial<Record<AgentName, ToolName[]>>;
 export declare const TURBO_TOOL_NAMES: readonly ["lean_turbo_plan_lanes", "lean_turbo_acquire_locks", "lean_turbo_runner_status", "lean_turbo_review", "lean_turbo_critic", "lean_turbo_run_phase", "lean_turbo_status"];
 export declare const TURBO_AGENT_TOOL_MAP: Partial<Record<AgentName, ToolName[]>>;
+/**
+ * Every Epic Mode tool. They stay registered in the plugin (TOOL_METADATA +
+ * TOOL_MANIFEST + barrel) but carry `agents: []`, so no agent sees them
+ * unless `epic.mode.enabled === true`, in which case they are merged
+ * into the architect's tool set at every opt-in merge site
+ * (`getAgentConfigs`, the architect prompt tool lists, the full-auto
+ * capability derivation).
+ */
+export declare const EPIC_TOOL_NAMES: readonly ["epic_next_wave", "epic_phase_review"];
+export declare const EPIC_AGENT_TOOL_MAP: Partial<Record<AgentName, ToolName[]>>;
 export declare const SKILL_TOOL_NAMES: readonly ["skill_generate", "skill_list", "skill_apply", "skill_inspect", "skill_regenerate", "skill_retire", "skill_improve"];
 export declare const SKILL_AGENT_TOOL_MAP: Partial<Record<AgentName, ToolName[]>>;
 export declare const PR_REVIEW_CHILD_TOOL_NAMES: readonly ["submit_pr_review_result"];
@@ -162,4 +172,4 @@ export declare const DEFAULT_LEAN_TURBO_CONFIG: LeanTurboConfig;
 export declare const SWARM_WORKTREE_DIR_NAME = ".swarm-worktrees";
 export declare const DEFAULT_WORKTREE_ISOLATION_CONFIG: WorktreeIsolationConfig;
 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";
-export declare const EPIC_MODE_BANNER = "## \uD83E\uDDED EPIC MODE ACTIVE\n\n**\u26D4 THE USER ALWAYS COMES FIRST \u2014 this overrides everything below.** The user can message you at ANY time, including mid-phase while coders are running or retrying. The instant a user message arrives \u2014 a question, a slash command, a comment, anything \u2014 STOP advancing the flow. Do not dispatch, do not retry, do not call another tool. Read what they said and respond to them directly, in plain conversation, first. Never keep executing the protocol and leave a user message unanswered \u2014 ignoring the user is the single worst failure mode in this mode. After you've answered, pick up where you left off. If you're mid-wave when they interrupt, tell them the state (\"3.1 and 3.2 are still running; I'll continue once I've answered you\") rather than going silent.\n\n**Activation \u2260 start.** Until the user asks for execution (\"start phase N\", \"run task X\", \"continue\"): do nothing. On `/swarm turbo epic`, `/swarm epic *` and any slash status/config command: call the named tool ONCE, surface its output VERBATIM, then stop. Don't infer intent \u2014 if unsure, ASK. This restraint applies ONLY before activation.\n\n**Talk to the user as you work** \u2014 like you naturally would. Once they ask you to run a phase, keep them in the loop with a sentence before each step about what you're doing and why (\"Declaring scopes for 3.1\u20133.3 so the planner can find parallelism\u2026\", \"Discrimination and calibration are independent, so I'll run 3.1 and 3.2 in parallel\u2026\"). This is normal conversation, not a form to fill in \u2014 the steps below tell you the key facts to share, but say them in your own voice. Don't go silent and tool-only through a phase.\n\nUse `epic_plan_waves` (NOT `lean_turbo_plan_lanes` or the deprecated `epic_run_phase`) for the wave plan. Do NOT call `lean_turbo_run_phase` directly.\n\n### Six-step flow (only when the user asks to run a phase)\n\n> Supersedes Rule 1a/3a: declare ALL pending scopes UP FRONT (step 1), BEFORE step 2. Just-in-time declaration breaks the wave planner.\n\n**1. `declare_scope` for every pending task** \u2014 one call per single `taskId` string (NOT ranges/arrays/globs). Tight, disjoint scopes; avoid shared files (`__init__.py`, barrels, registries) \u2014 they force serial waves. Declared scope is a CONTRACT; if a task needs more files mid-run, re-declare BEFORE dispatching.\n\n**2. `epic_decide_phase(directory, phase=N, sessionID)`** \u2014 returns:\n- `decided`+`promote` \u2192 step 3\n- `demoted` \u2192 step 6 (per-task serial)\n- `scopes-missing` \u2192 `declare_scope` each `missingScopes[]`, retry step 2\n- `no-phase` | `phase-empty` | `phase-already-complete` | `epic-state-unreadable` \u2192 fix per response `message`, retry. `phase-already-complete` means call step 2 with `phase=N+1` (NOT step 4 directly).\n- other \u2192 fix per `message`, retry\n\n**3. Surface the verdict to the user immediately, before any further action:**\n> Epic Mode: <PROMOTE|DEMOTE> (p=<value>) \u2014 <one-sentence rationale or top blocking reason>\n> Dependencies: <task_id> \u2190 <deps>; \u2026 (omit if none)\n\nThe verdict is the user's only visibility into what Epic is doing \u2014 silence here makes the mode invisible. If you're going to spend time on this phase, tell the user why up front. Phrase it naturally; the format above is a guide, not a script.\n\n**4. `epic_plan_waves(directory, phase=N)`** \u2014 returns `{ waves: [{ waveId, taskIds, files }], serializedTasks, degradedTasks, degradationSummary }`. Failure reasons mirror step 2; additionally: `git-failed` (retry), `planner-error` (check `errors[0]`).\n\n**4b. Surface the wave plan to the user, before dispatching any `Task`:**\n> Wave plan (<N> waves): Wave 1 \u2192 [<ids>] (parallel); Wave 2 \u2192 [<ids>]; \u2026 \u2014 serialized [<ids>], degraded [<ids>]\n\nWalk them through which tasks run in which wave and what's parallel \u2014 naturally, in your own words. If `waves.length` exceeds the distinct-dependency-layer count, also flag the over-split and its likely cause (typical: a shared file like a barrel/registry in multiple scopes forces serial waves), e.g. \"Wave N split into K single-task waves because every scope claims `<shared-file>` \u2014 re-declare those tasks without it to restore parallelism, then re-plan.\"\n\n`serializedTasks` causes (NOT `declare_scope`-fixable): cycle, `no-scope`, `invalid-scope`, cap-exhaustion. Fix dep graph or scope contents, re-plan.\n\n`degradedTasks[].reason` keys:\n- `global file conflict` / `protected path` \u2192 balanced mode, dispatch per-task after waves\n- `cross-batch upstream not committed (greenfield-smart Rule 3): <ids>` \u2192 commit named upstreams, re-plan\n- `unresolved in-batch dependency: <ids>` \u2192 fix upstream degrade/serialize, re-plan\n- `planning leftover (no identifiable blocker)` \u2192 surface as planner bug\n\n**5. Dispatch each wave: `wave.taskIds.length` SEPARATE `Task` calls in ONE assistant message.** Per wave in order:\n- One `Task(subagent_type=\"coder\", description=\"Phase N task <id>\", prompt=\"<scope + acceptance>\")` per `taskId`\n- ALL in same turn \u2192 concurrent\n- Wait for all in wave to reach `update_task_status(completed)` + `epic_record_divergence` before next wave\n\n\u26A0\uFE0F **Three defects:**\n1. **Bundling**: multiple ids in one Task call \u2192 kills 1:1 coder visibility\n2. **Splitting across messages**: serial execution, no parallelism\n3. **Skipping single-task waves**: still emit ONE Task, wait for completion+divergence\n\nThis is the only sanctioned dispatch path. Don't use `lean_turbo_run_phase`; don't bundle through other tools \u2014 visibility requires `Task`.\n\n`serializedTasks` + `degradedTasks` (after wave loop): ONE Task per assistant message each, never batched, wait for completion+divergence between.\n\n**6. After each `update_task_status(completed)`, call `epic_record_divergence(directory, taskId, sessionID)`** (feeds calibration). If `summary.isClean: false`:\n> Divergence: task `<id>` wrote <undeclaredCount> undeclared file(s) (ratio <ratio>)\n\n### Phase-complete + audit\n\nPhase reviewer + critic still required at `phase_complete` (Epic Mode doesn't change Stage B).\n\nAudit (no architect needed): `/swarm epic status | last | decide | calibration`.\n";
+export declare const EPIC_MODE_BANNER = "## \uD83E\uDDED EPIC MODE ACTIVE \u2014 an epic is open for this plan\n\n**\u26D4 THE USER ALWAYS COMES FIRST \u2014 this overrides everything below.** The user can message you at ANY time, including mid-wave while coders are running or retrying. The instant a user message arrives \u2014 a question, a slash command, a comment, anything \u2014 STOP advancing the flow: no dispatch, no retry, no further tool call. Answer them directly, in plain conversation, first \u2014 ignoring the user is the worst failure mode here. Then resume; if mid-wave, tell them the state (\"3.1 and 3.2 are still running; I'll continue once I've answered you\") rather than going silent.\n\n**An open epic \u2260 start.** The user opened it with `/swarm epic start`; until they ask for execution (\"start phase N\", \"run task X\", \"continue\"): do nothing. On `/swarm epic *` and any slash status/config command: call the named tool ONCE, surface its output VERBATIM, then stop. Don't infer intent \u2014 if unsure, ASK. Only the user opens or closes an epic. Epic enables neither Turbo nor Lean.\n\n**Talk to the user as you work.** Once they ask you to run the plan, say a sentence before each step about what you're doing and why \u2014 never go silent and tool-only.\n\n### How to run it: call `epic_next_wave` and do exactly what its `status` says\n\nIt plans every wave, closes finished waves, and keeps phases in order. Never plan waves yourself; never call `lean_turbo_run_phase` / `lean_turbo_plan_lanes`.\n- `dispatch` \u2192 follow its `instructions`: one `Task` per `taskId`, ALL in ONE message; per task Stage A (`pre_check_batch`) \u2192 Stage B (`reviewer` + `test_engineer`) \u2192 `update_task_status(completed)`; then call `epic_next_wave` again.\n- `declare-scopes` \u2192 `declare_scope` once per listed `taskId` (start from `suggestedFiles`), then call again.\n- `in-progress` \u2192 finish the listed tasks, then call again.\n- `blocked` \u2192 relay `message` to the user and apply its remedy.\n- `phase-ready-for-review` \u2192 `epic_phase_review(phase)` ONCE (phase reviewer, then critic). Both APPROVED \u2192 your normal PHASE-WRAP (phase-wrap skill: docs agent, `write_retro`, \u2026) \u2192 `phase_complete` \u2192 `epic_next_wave`; otherwise add each fix as a NEW pending task of that phase (`save_plan`) and call `epic_next_wave` (it runs them as a fix wave), then re-run it. Never re-dispatch a coder outside a wave.\n- `epic-complete` \u2192 tell the user to close the epic with `/swarm epic close`.\n- `refused` \u2192 relay `message`; run tasks per-task serially.\n\nPer-task QA (Stage A + Stage B) is NEVER waived in Epic. Audit (no architect needed): `/swarm epic status | learning`.\n";

package/dist/config/loader.d.ts

@@ -3,6 +3,8 @@ import { type GateConfigOverrides, type PluginConfig } from './schema';
 export declare const MAX_CONFIG_FILE_BYTES = 102400;
 export declare const _internals: {
     resetUnknownTopLevelKeyWarning(): void;
+    resetRetiredEpicKeyWarning(): void;
+    resetLegacyEpicConfigWarning(): void;
     resetGatesAdvisoryDedup(): void;
 };
 export { deepMerge, MAX_MERGE_DEPTH } from '../utils/merge';