opencode-swarm 7.86.0 → 7.87.0

package/dist/cli/{index-yx44zd0p.js → index-zgwm4ryv.js}

@@ -27,6 +27,14 @@ function warn(message, data) {
     console.warn(`[opencode-swarm ${timestamp}] WARN: ${message}`);
   }
 }
+function criticalWarn(message, data) {
+  const timestamp = new Date().toISOString();
+  if (data !== undefined) {
+    console.warn(`[opencode-swarm ${timestamp}] CRITICAL-WARN: ${message}`, data);
+  } else {
+    console.warn(`[opencode-swarm ${timestamp}] CRITICAL-WARN: ${message}`);
+  }
+}
 function error(message, data) {
   const timestamp = new Date().toISOString();
   if (data !== undefined) {
@@ -37,4 +45,4 @@ function error(message, data) {
 }
 var init_logger = () => {};
 
-export { log, warn, error, init_logger };
+export { log, warn, criticalWarn, error, init_logger };

package/dist/cli/index.js

@@ -7,26 +7,26 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-5q66xc88.js";
-import"./index-vq2321gg.js";
+} from "./index-wv2yj8ka.js";
+import"./index-5hvbw5xh.js";
 import"./index-yhsmmv2z.js";
-import"./index-d9fbxaqd.js";
+import"./index-s8bj492g.js";
 import"./index-e8pk68cc.js";
-import"./index-0sxvwjt0.js";
+import"./index-1cb4wxnm.js";
 import {
   DEFAULT_AGENT_CONFIGS
-} from "./index-hw9b2xng.js";
-import"./index-red8fm8p.js";
-import"./index-f8r50m3h.js";
-import"./index-hz59hg4h.js";
+} from "./index-q9h0wb04.js";
+import"./index-89xjr3h4.js";
+import"./index-adz3nk9b.js";
+import"./index-v4fcn4tr.js";
 import"./index-e7h9bb6v.js";
 import"./index-fjwwrwr5.js";
-import"./index-eb85wtx9.js";
-import"./index-ckntc5gf.js";
+import"./index-vqyfscxd.js";
+import"./index-gn8n22th.js";
 import"./index-jtqkh8jf.js";
-import"./index-zfsbaaqh.js";
+import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
-import"./index-yx44zd0p.js";
+import"./index-zgwm4ryv.js";
 import"./index-bcp79s17.js";
 import"./index-293f68mj.js";
 import"./index-b9v501fr.js";

package/dist/cli/{pending-delegations-rd40tv9s.js → pending-delegations-35fvcj7z.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-ckntc5gf.js";
+} from "./index-gn8n22th.js";
 import"./index-jtqkh8jf.js";
-import"./index-zfsbaaqh.js";
+import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import {
   init_logger,
   warn
-} from "./index-yx44zd0p.js";
+} from "./index-zgwm4ryv.js";
 import {
   withEvidenceLock
 } from "./index-bcp79s17.js";

package/dist/cli/{pr-subscriptions-y1nn36e5.js → pr-subscriptions-b18n1yd8.js}

@@ -9,12 +9,12 @@ import {
   sweepStale,
   unsubscribe,
   updateSnapshot
-} from "./index-eb85wtx9.js";
-import"./index-ckntc5gf.js";
+} from "./index-vqyfscxd.js";
+import"./index-gn8n22th.js";
 import"./index-jtqkh8jf.js";
-import"./index-zfsbaaqh.js";
+import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
-import"./index-yx44zd0p.js";
+import"./index-zgwm4ryv.js";
 import"./index-bcp79s17.js";
 import"./index-293f68mj.js";
 import"./index-b9v501fr.js";

package/dist/cli/{schema-8d32b2v6.js → schema-84146tvk.js}

@@ -26,6 +26,7 @@ import {
   DesignDocsConfigSchema,
   DiscoverySourceSchema,
   DocsConfigSchema,
+  EpicConfigSchema,
   EvidenceConfigSchema,
   ExternalSkillCandidateEvaluationVerdictSchema,
   ExternalSkillCandidateSchema,
@@ -80,7 +81,7 @@ import {
   resolveGeneratedAgentRole,
   resolveGuardrailsConfig,
   stripKnownSwarmPrefix
-} from "./index-hw9b2xng.js";
+} from "./index-q9h0wb04.js";
 import"./index-p0arc26j.js";
 import"./index-293f68mj.js";
 import"./index-a76rekgs.js";
@@ -139,6 +140,7 @@ export {
   ExternalSkillCandidateSchema,
   ExternalSkillCandidateEvaluationVerdictSchema,
   EvidenceConfigSchema,
+  EpicConfigSchema,
   DocsConfigSchema,
   DiscoverySourceSchema,
   DesignDocsConfigSchema,

package/dist/cli/{skill-generator-a5ehggyg.js → skill-generator-3pvpk4y2.js}

@@ -21,11 +21,11 @@ import {
   retireSkill,
   sanitizeSlug,
   selectCandidateEntries
-} from "./index-d9fbxaqd.js";
+} from "./index-s8bj492g.js";
 import"./index-e8pk68cc.js";
 import"./index-fjwwrwr5.js";
 import"./index-jtqkh8jf.js";
-import"./index-yx44zd0p.js";
+import"./index-zgwm4ryv.js";
 import"./index-bcp79s17.js";
 import"./index-b9v501fr.js";
 import"./index-p0ye10nd.js";

package/dist/commands/coupling.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `/swarm coupling` — read-only coupling report (Epic mode, Capability B).
+ *
+ * Computes `p` for the current plan and surfaces the modules that contribute
+ * most to detected coupling, with a ranked decoupling roadmap. Read-only:
+ * changes no execution behavior; with the optional `--persist` flag, writes
+ * 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.
+ *
+ * Flags:
+ *   --phase <n>             Scope to one phase (default: whole plan).
+ *   --threshold <number>    NPMI floor override (default: EpicConfigSchema 0.6).
+ *   --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.
+ */
+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
+ * when `--persist` is on.
+ */
+export declare function handleCouplingCommand(directory: string, args: string[]): Promise<string>;
+/**
+ * Test-only DI seam. Production code calls `_internals.fn(...)` so tests can
+ * replace these without `mock.module` (AGENTS.md invariant 7).
+ */
+export declare const _internals: {
+    loadPlanJsonOnly: typeof loadPlanJsonOnly;
+    getCoChangePairs: typeof getCoChangePairs;
+};

package/dist/commands/epic.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `/swarm epic` — Epic Mode activation toggle and diagnostics (Capability C).
+ *
+ * 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`)
+ *
+ * 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.
+ */
+import { loadPluginConfigWithMeta } from '../config/index.js';
+import { isGitRepo } from '../git/branch.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).
+ */
+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;
+};
+export declare function handleEpicCommand(directory: string, args: string[], sessionID: string): Promise<string>;

package/dist/commands/registry.d.ts

@@ -316,6 +316,22 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "utility";
         readonly toolPolicy: "restricted";
     };
+    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 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 category: "diagnostics";
+        readonly toolPolicy: "none";
+    };
     readonly 'dark-matter': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Detect hidden file couplings via co-change NPMI analysis";
@@ -644,8 +660,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|status]";
-        readonly args: "on, off, lean, standard, status";
+        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 details: string;
         readonly category: "utility";
         readonly toolPolicy: "none";

package/dist/config/constants.d.ts

@@ -93,3 +93,4 @@ export declare const AUTO_PROCEED_BANNER = "## \u23ED\uFE0F AUTO-PROCEED STATUS\
 export declare const DEFAULT_LEAN_TURBO_CONFIG: LeanTurboConfig;
 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";

package/dist/config/schema.d.ts

@@ -965,6 +965,37 @@ export declare const LeanTurboConfigSchema: z.ZodObject<{
     worktree_dir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type LeanTurboConfig = z.infer<typeof LeanTurboConfigSchema>;
+/**
+ * Epic mode — co-change-aware conflict detection settings.
+ *
+ * Epic mode is an additive layer that composes Lean Turbo (it never modifies it).
+ * Capability A surfaces git co-change history as an extra conflict signal so
+ * pairs of files that historically change together can be treated as conflicting
+ * even when path-based rules would not catch the coupling.
+ *
+ * With `cochange.enabled: false` (the default), no Epic-mode code runs in any
+ * existing flow — behavior is identical to upstream Lean Turbo.
+ */
+export declare const EpicConfigSchema: z.ZodObject<{
+    cochange: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        threshold: z.ZodDefault<z.ZodNumber>;
+        min_co_changes: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    mode: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        activation_threshold: z.ZodDefault<z.ZodNumber>;
+        min_commits_for_signal: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    calibration: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        floor_threshold: z.ZodDefault<z.ZodNumber>;
+        tighten_step: z.ZodDefault<z.ZodNumber>;
+        loosen_step: z.ZodDefault<z.ZodNumber>;
+        loosen_window: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EpicConfig = z.infer<typeof EpicConfigSchema>;
 export declare const StandardTurboConfigSchema: z.ZodObject<{
     strategy: z.ZodLiteral<"standard">;
     lean: z.ZodOptional<z.ZodObject<{
@@ -987,6 +1018,25 @@ export declare const StandardTurboConfigSchema: z.ZodObject<{
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    epic: z.ZodOptional<z.ZodObject<{
+        cochange: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            threshold: z.ZodDefault<z.ZodNumber>;
+            min_co_changes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        mode: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            activation_threshold: z.ZodDefault<z.ZodNumber>;
+            min_commits_for_signal: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        calibration: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            floor_threshold: z.ZodDefault<z.ZodNumber>;
+            tighten_step: z.ZodDefault<z.ZodNumber>;
+            loosen_step: z.ZodDefault<z.ZodNumber>;
+            loosen_window: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export declare const LeanTurboStrategyConfigSchema: z.ZodObject<{
     strategy: z.ZodLiteral<"lean">;
@@ -1010,6 +1060,25 @@ export declare const LeanTurboStrategyConfigSchema: z.ZodObject<{
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    epic: z.ZodOptional<z.ZodObject<{
+        cochange: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            threshold: z.ZodDefault<z.ZodNumber>;
+            min_co_changes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        mode: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            activation_threshold: z.ZodDefault<z.ZodNumber>;
+            min_commits_for_signal: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        calibration: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            floor_threshold: z.ZodDefault<z.ZodNumber>;
+            tighten_step: z.ZodDefault<z.ZodNumber>;
+            loosen_step: z.ZodDefault<z.ZodNumber>;
+            loosen_window: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export declare const TurboConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     strategy: z.ZodLiteral<"standard">;
@@ -1033,6 +1102,25 @@ export declare const TurboConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    epic: z.ZodOptional<z.ZodObject<{
+        cochange: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            threshold: z.ZodDefault<z.ZodNumber>;
+            min_co_changes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        mode: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            activation_threshold: z.ZodDefault<z.ZodNumber>;
+            min_commits_for_signal: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        calibration: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            floor_threshold: z.ZodDefault<z.ZodNumber>;
+            tighten_step: z.ZodDefault<z.ZodNumber>;
+            loosen_step: z.ZodDefault<z.ZodNumber>;
+            loosen_window: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>, z.ZodObject<{
     strategy: z.ZodLiteral<"lean">;
     lean: z.ZodObject<{
@@ -1055,6 +1143,25 @@ export declare const TurboConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    epic: z.ZodOptional<z.ZodObject<{
+        cochange: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            threshold: z.ZodDefault<z.ZodNumber>;
+            min_co_changes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        mode: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            activation_threshold: z.ZodDefault<z.ZodNumber>;
+            min_commits_for_signal: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        calibration: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            floor_threshold: z.ZodDefault<z.ZodNumber>;
+            tighten_step: z.ZodDefault<z.ZodNumber>;
+            loosen_step: z.ZodDefault<z.ZodNumber>;
+            loosen_window: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>], "strategy">;
 export type TurboConfig = z.infer<typeof TurboConfigSchema>;
 /** Where an external skill candidate was discovered. */
@@ -1864,6 +1971,25 @@ export declare const PluginConfigSchema: z.ZodObject<{
             }>>>;
             worktree_dir: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        epic: z.ZodOptional<z.ZodObject<{
+            cochange: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                threshold: z.ZodDefault<z.ZodNumber>;
+                min_co_changes: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            mode: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                activation_threshold: z.ZodDefault<z.ZodNumber>;
+                min_commits_for_signal: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            calibration: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                floor_threshold: z.ZodDefault<z.ZodNumber>;
+                tighten_step: z.ZodDefault<z.ZodNumber>;
+                loosen_step: z.ZodDefault<z.ZodNumber>;
+                loosen_window: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>, z.ZodObject<{
         strategy: z.ZodLiteral<"lean">;
         lean: z.ZodObject<{
@@ -1886,6 +2012,25 @@ export declare const PluginConfigSchema: z.ZodObject<{
             }>>>;
             worktree_dir: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
+        epic: z.ZodOptional<z.ZodObject<{
+            cochange: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                threshold: z.ZodDefault<z.ZodNumber>;
+                min_co_changes: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            mode: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                activation_threshold: z.ZodDefault<z.ZodNumber>;
+                min_commits_for_signal: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            calibration: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                floor_threshold: z.ZodDefault<z.ZodNumber>;
+                tighten_step: z.ZodDefault<z.ZodNumber>;
+                loosen_step: z.ZodDefault<z.ZodNumber>;
+                loosen_window: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>], "strategy">>;
     turbo_mode: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     quiet: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;

package/dist/git/branch.d.ts

@@ -6,7 +6,28 @@ export type GitRepositoryStatus = {
     message: string;
 };
 /**
- * Execute git command safely
+ * Execute git command safely.
+ *
+ * Non-interactive enforcement (AGENTS.md #3): three defenses ensure git
+ * cannot block on a TTY prompt — GPG passphrase, credential helper,
+ * "are you sure?" rebase confirmation, etc.
+ *
+ *  1. `stdio: ['ignore', ...]` closes the child's stdin. A prompt has
+ *     no input source, so git/GPG/credential-helper sees EOF.
+ *  2. `GIT_TERMINAL_PROMPT=0` tells git itself to refuse any prompt
+ *     attempt outright rather than falling back to the controlling
+ *     terminal (some prompts route through git, not the child).
+ *  3. `-c commit.gpgsign=false -c tag.gpgsign=false` prepended to every
+ *     command. Closes the SILENT-failure path where a developer/CI host
+ *     has `commit.gpgsign=true` globally and no GPG agent — without (3),
+ *     defenses (1)+(2) merely turn the prompt-hang into an immediate
+ *     non-zero exit, which `commitTaskCompletion` catches as
+ *     `commit-failed` non-fatally. Result: every Epic Rule 2 commit
+ *     silently fails, predecessor-evidence never accumulates, every
+ *     phase demotes. (3) forces the underlying git subcommand to skip
+ *     signing entirely. This is the single source of truth for
+ *     non-interactive git, so the hardening covers every caller
+ *     (current and future) uniformly.
  */
 declare function gitExec(args: string[], cwd: string): string;
 export declare function getGitRepositoryStatus(cwd: string): GitRepositoryStatus;

package/dist/hooks/delegation-gate/worktree-merge-status.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Worktree merge-back status registry (leaf module — no app imports).
+ *
+ * Bridges two subsystems that otherwise cannot see each other:
+ *
+ *   - WORKTREE ISOLATION (`worktree-isolation.ts`) knows, at merge-back
+ *     time, whether a Task-dispatched coder's isolated worktree merged
+ *     cleanly back into the main tree.
+ *   - EPIC MODE Rule 2 (`plan/manager.updateTaskStatus`) auto-commits a
+ *     `swarm(task <id>):` marker on completion. That marker is the
+ *     evidence Rule 3 scans to decide a downstream task's upstream is
+ *     satisfied.
+ *
+ * Without this bridge, a coder whose worktree merge-back FAILED (conflict)
+ * leaves its changes stranded in the preserved worktree, yet Rule 2 would
+ * still fire an `--allow-empty` marker and Rule 3 would treat the task as
+ * done — silently advancing the plan past work that never landed.
+ *
+ * This module is deliberately a LEAF: it imports nothing from the app so
+ * that both `worktree-isolation.ts` (writer) and `plan/manager.ts` (reader)
+ * can depend on it without creating an import cycle.
+ *
+ * STATE DURABILITY: Status is stored in an in-memory Map (fast, per-process)
+ * AND persisted to `.swarm/worktree-merge-status.json` (survives plugin restart).
+ * On each write, the JSON file is atomically updated. On read, the in-memory
+ * map is checked first (fast path); on plugin restart, the map is empty but
+ * the durable file is restored on first read or Rule 2 lookup.
+ */
+/** Why a task's worktree work did not fully reach the main tree. */
+export type WorktreeMergeOutcome = 'partial' | 'failed';
+export interface WorktreeMergeFailure {
+    outcome: WorktreeMergeOutcome;
+    /** Pipeline stage that failed (e.g. 'merge', 'auto-commit'). */
+    stage: string;
+    /** Human-readable detail surfaced in the Rule 2 skip warning. */
+    message: string;
+}
+declare function getDurableStatusPath(projectDir?: string): string;
+/**
+ * Load the durable file into the in-memory map. The clear+repopulate is
+ * synchronous (no `await`), so no read can observe a transiently-empty map
+ * in Node's single-threaded model. Called only from init and the one-shot
+ * lazy load — never on a steady-state lookup.
+ */
+declare function loadDurableStatus(statusPath: string): void;
+declare function saveDurableStatus(statusPath: string): void;
+/**
+ * Initialize the durable status path for this project and load existing
+ * status from disk. Called from `createDelegationGateHook` before any coder
+ * dispatches. Re-initializing the SAME path is a no-op (the in-memory map is
+ * already the live authority); switching to a DIFFERENT path reloads.
+ */
+export declare function initDurableStatusPath(projectDir: string): void;
+/**
+ * Record that task `taskId`'s worktree merge-back did not fully land.
+ * No-op when `taskId` is undefined (non-plan dispatches carry no plan id
+ * and are never subject to Epic Rule 2).
+ */
+export declare function recordWorktreeMergeFailure(taskId: string | undefined, failure: WorktreeMergeFailure): void;
+/**
+ * Clear any recorded failure for `taskId`. Called when a (re-)dispatch of
+ * the same task merges cleanly, so a later success supersedes an earlier
+ * failure and Rule 2 is allowed to commit the marker again.
+ */
+export declare function clearWorktreeMergeStatus(taskId: string | undefined): void;
+/**
+ * Query whether task `taskId`'s most recent worktree merge-back failed.
+ * Returns the failure detail, or undefined when the task merged cleanly,
+ * was never worktree-isolated, or has no recorded status.
+ * On first read after plugin restart, loads from durable storage.
+ */
+export declare function getWorktreeMergeFailure(taskId: string): WorktreeMergeFailure | undefined;
+/**
+ * @internal test seam. Use `resetForTest()` in afterEach to isolate tests
+ * that set durableStatusPath via `initDurableStatusPath`.
+ */
+export declare const _internals: {
+    failuresByTask: Map<string, WorktreeMergeFailure>;
+    getDurableStatusPath: typeof getDurableStatusPath;
+    loadDurableStatus: typeof loadDurableStatus;
+    saveDurableStatus: typeof saveDurableStatus;
+    initDurableStatusPath: typeof initDurableStatusPath;
+    /** Reset both in-memory and durable state for test isolation. */
+    resetForTest(): void;
+};
+export {};