opencode-swarm 7.189.0 → 7.190.0

package/dist/plan/manager.d.ts

@@ -48,11 +48,8 @@ export interface AcknowledgedRemovals {
     source: string;
 }
 import { type Plan, type RuntimePlan, type TaskStatus } from '../config/plan-schema';
-import { isGitRepo } from '../git/branch';
-import { getWorktreeMergeFailure } from '../hooks/delegation-gate/worktree-merge-status';
+import { epicMergeFailureSkipsCheckpoint } from '../epic/merge-epoch.js';
 import { recordTaskAttempt } from '../services/run-memory.js';
-import { isEpicModeActiveForProject } from '../turbo/epic/state.js';
-import { commitTaskCompletion } from '../turbo/epic/task-commit.js';
 import type { AutoCheckpointOutcome } from './auto-checkpoint.js';
 import { type LedgerEvent, type LedgerEventInput, ledgerExists, loadLastApprovedPlan, readLedgerEventsWithIntegrity, replayFromLedger, takeSnapshotWithRetry } from './ledger';
 /** Reset the startup ledger check flag. For testing only. */
@@ -77,10 +74,11 @@ export declare const _internals: {
     loadLastApprovedPlan: typeof loadLastApprovedPlan;
     readLedgerEventsWithIntegrity: typeof readLedgerEventsWithIntegrity;
     regeneratePlanMarkdown: typeof regeneratePlanMarkdown;
-    isGitRepo: typeof isGitRepo;
-    isEpicModeActiveForProject: typeof isEpicModeActiveForProject;
-    commitTaskCompletion: typeof commitTaskCompletion;
-    getWorktreeMergeFailure: typeof getWorktreeMergeFailure;
+    /**
+     * Epic v2 C3: skip the #2582 auto-checkpoint for an open epic's task
+     * whose worktree merge-back failed (one existsSync when no epic).
+     */
+    epicMergeFailureSkipsCheckpoint: typeof epicMergeFailureSkipsCheckpoint;
     recordTaskAttempt: typeof recordTaskAttempt;
     /**
      * Issue #2582 — the checkpoint.auto_checkpoint_threshold runtime trigger,

package/dist/plan/parallel-verdict.d.ts

@@ -36,8 +36,8 @@
  *    acceptance criterion.
  */
 import { type Plan } from '../config/plan-schema.js';
+import { type CoChangeThreshold } from '../epic/cochange-conflict.js';
 import type { CoChangeEntry } from '../tools/co-change-analyzer.js';
-import { type CoChangeThreshold } from '../turbo/epic/cochange-conflict.js';
 /**
  * Per-pair conflict classification. Mirrors `EpicPairVerdict`'s signal
  * decomposition but flattens `none` into `disjoint` for the plan-level view.
@@ -84,12 +84,23 @@ export interface ComputeParallelVerdictOptions {
      * or unparseable plan resolves every task to `unknown` (fail-closed).
      */
     plan?: Plan;
+    /**
+     * Explicit per-task scopes (Epic v2 C4: an epic wave's FROZEN declared
+     * scopes). When present, every task's scope is resolved ONLY from this
+     * map — the binding store is never read (no
+     * `readAuthoritativeScopeBindingSet` scan) and `plan` is neither needed
+     * nor read (it may be omitted). A task missing from the map, or mapped to an
+     * empty list, is `unknown` (fail-closed). When absent, behaviour is
+     * unchanged: scopes come from the live v2 bindings.
+     */
+    scopes?: Record<string, string[]>;
 }
 /**
  * Compute a pairwise conflict verdict for the given task ids.
  *
  * Pure + synchronous. Reads only the authoritative v2 binding store (plus a
- * bounded plan.json read when `options.plan` is omitted). Writes nothing.
+ * bounded plan.json read when `options.plan` is omitted) — or nothing at all
+ * when `options.scopes` supplies the scopes explicitly. Writes nothing.
  * Fail-closed on any read/parse error (treats the task as `unknown`).
  *
  * @param directory  Project root (for the binding store and plan.json reads).

package/dist/retention/caps.d.ts

@@ -12,7 +12,7 @@
  * both the Bun and Node hosts (AGENTS.md invariant 2).
  */
 /** Canonical cap names (frozen by the #2483 acceptance checks). */
-export type RetentionCapName = 'MAX_RETRACTION_RECORDS' | 'MAX_UNACKNOWLEDGED_CRITICALS' | 'MAX_CURATION_PROPOSALS' | 'MAX_CONSOLIDATION_LOG_ENTRIES' | 'MAX_CONTEXT_SNAPSHOT_BYTES' | 'MAX_CONTEXT_SNAPSHOT_ENTRIES' | 'MAX_CALIBRATION_MODULES' | 'MAX_DIVERGENCE_BYTES' | 'MAX_TEST_HISTORY_ENTRIES' | 'MAX_TEST_HISTORY_KEYS' | 'MAX_SKILL_CHANGELOG_ENTRIES_PER_SKILL' | 'MAX_SKILL_CHANGELOG_GLOBAL_ENTRIES' | 'MAX_RECEIPTS_READ' | 'MAX_CAPSULES_LISTED' | 'MAX_SUMMARIES_LISTED' | 'MAX_RUN_LOG_ENTRIES' | 'MAX_UNITID_PROBE_ENTRIES';
+export type RetentionCapName = 'MAX_RETRACTION_RECORDS' | 'MAX_UNACKNOWLEDGED_CRITICALS' | 'MAX_CURATION_PROPOSALS' | 'MAX_CONSOLIDATION_LOG_ENTRIES' | 'MAX_CONTEXT_SNAPSHOT_BYTES' | 'MAX_CONTEXT_SNAPSHOT_ENTRIES' | 'MAX_EPIC_LEARNING_FILES' | 'MAX_EPIC_LEARNING_EDGES' | 'MAX_TEST_HISTORY_ENTRIES' | 'MAX_TEST_HISTORY_KEYS' | 'MAX_SKILL_CHANGELOG_ENTRIES_PER_SKILL' | 'MAX_SKILL_CHANGELOG_GLOBAL_ENTRIES' | 'MAX_RECEIPTS_READ' | 'MAX_CAPSULES_LISTED' | 'MAX_SUMMARIES_LISTED' | 'MAX_RUN_LOG_ENTRIES' | 'MAX_UNITID_PROBE_ENTRIES';
 /**
  * Install test cap overrides (partial). Production code never calls this;
  * tests and the #2483 acceptance checks do. Values are validated to be

package/dist/review/contracts.d.ts

@@ -1,5 +1,5 @@
 import type { OpencodeClient } from '@opencode-ai/sdk';
-import { type EphemeralAgentDispatchResult } from '../evaluation/ephemeral-agent-dispatcher.js';
+import { type EphemeralAgentDispatchResult, type ReadOnlyToolDenials } from '../evaluation/ephemeral-agent-dispatcher.js';
 import type { PricingConfig } from '../services/cost-accounting.js';
 import type { ModelOverride } from '../utils/model-dispatch-fallback.js';
 export type ReviewDispatchRequest = {
@@ -16,6 +16,13 @@ export type ReviewDispatchRequest = {
     promptByteLimit?: number;
     responseByteLimit?: number;
     abortSignal?: AbortSignal;
+    /**
+     * Tool-denial map for the isolated session. Omitted ⇒
+     * `DEFAULT_READ_ONLY_TOOLS` (every caller except Epic's phase review,
+     * whose provider-refusal retry keeps `bash` — see
+     * `src/epic/phase-readiness.ts`).
+     */
+    tools?: ReadOnlyToolDenials;
 };
 export type ReviewDispatchResult = EphemeralAgentDispatchResult;
 export interface ReviewModelDispatcher {

package/dist/services/config-doctor.d.ts

@@ -4,6 +4,7 @@
  * Validates opencode-swarm config shape, detects stale/invalid settings,
  * classifies findings by severity, and proposes safe auto-fixes.
  */
+import { type ConfigConsumerDeclaration } from '../config/consumers';
 import type { PluginConfig } from '../config/schema';
 import { loadPlanJsonOnly } from '../plan/manager';
 /**
@@ -30,6 +31,20 @@ export declare const DEFAULT_FLIPS: ReadonlyArray<{
     sinceVersion: number;
     evidence: string;
 }>;
+/**
+ * Inert config-key advisories (issue #2904), driven by the RAW config files so
+ * they fire ONLY when the user explicitly wrote the key — schema defaults never
+ * produce noise (same contract as the #2102 raw collectors above). The inert set
+ * comes from CONFIG_CONSUMERS (`src/config/consumers.ts`), the single
+ * declaration of consumer truth enforced by `bun run scripts/check-config-consumption.ts`.
+ *
+ * The `consumers` parameter is a default-parameter DI seam (issue #2957): tests
+ * inject declaration states so both arms of `ConfigConsumerDeclaration`
+ * (inert / consumed) are provable on any tree, without `mock.module` — the same
+ * pattern as `collectLeanTurboGateSatisfiabilityFindings`'s
+ * `registeredToolNames` seam below.
+ */
+export declare function collectRawInertKeyFindings(directory: string, consumers?: Readonly<Record<string, ConfigConsumerDeclaration>>): ConfigFinding[];
 /**
  * Lean Turbo evidence-requiring gates and the registered producer tool that
  * writes each gate's evidence (issue #2470: every evidence-requiring gate must
@@ -58,6 +73,29 @@ export declare const LEAN_TURBO_GATE_PRODUCERS: readonly [{
  * gate becomes structurally unsatisfiable and this lint fails with an error.
  */
 export declare function collectLeanTurboGateSatisfiabilityFindings(config: PluginConfig, registeredToolNames?: ReadonlySet<string>): ConfigFinding[];
+/**
+ * Retired Epic config keys (Epic v2). The schema accepts and strips them
+ * (with a precise "retired" loader warning instead of an unrecognized-key
+ * recovery), so the parsed config the doctor walks no longer has them; read
+ * the raw user + project files instead. Only when the parsed config has an
+ * Epic block (top-level `epic`, or the legacy `turbo.epic` — every retired key
+ * lives in one): a non-Epic doctor run reads no extra file. Report-only:
+ * nothing reads the key, and removing it is the user's edit (no auto-fix
+ * writes the config for a no-op key).
+ */
+export declare function collectRawRetiredEpicKeyFindings(config: PluginConfig, directory: string): ConfigFinding[];
+/**
+ * Legacy Epic config path (Epic C9): a config file that still sets
+ * `turbo.epic`. The loader migrates it to that file's top-level `epic`
+ * (per-key merge, the file's top-level `epic` wins) before the files are
+ * merged, and keeps honoring it permanently; this finding tells the user
+ * where to move it. Report-only, like `retired-config-key`: the doctor's fix
+ * model (`remove` / `update` / `add` of one value, on the one preferred
+ * config file) has no move-and-merge, and it would only ever touch one of
+ * the two files. Only when the parsed config has an Epic block: a non-Epic
+ * doctor run reads no extra file.
+ */
+export declare function collectRawLegacyEpicConfigFindings(config: PluginConfig, directory: string): ConfigFinding[];
 /**
  * Test-only dependency-injection seam per invariant 7 (mock.module leaks
  * across files in Bun's shared test runner; `loadPlanJsonOnly` is a frequent

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

@@ -2,12 +2,14 @@
  * Session snapshot reader for OpenCode Swarm plugin.
  * Reads .swarm/session/state.json and rehydrates swarmState on plugin init.
  */
+import { isEpicOpenForProject } from '../epic/lifecycle.js';
 import type { AgentSessionState } from '../state';
 import { type HydrationScope } from './hydration-ownership.js';
 import { recordInterruptedExecution } from './restart-reconciliation.js';
 import type { SerializedAgentSession, SnapshotData } from './snapshot-writer';
 export declare const _internals: {
     recordInterruptedExecution: typeof recordInterruptedExecution;
+    isEpicOpenForProject: typeof isEpicOpenForProject;
 };
 /**
  * Transient session fields that must be reset on rehydration.

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

@@ -36,7 +36,13 @@ export interface SerializedAgentSession {
     turboStrategy?: 'standard' | 'lean';
     leanTurboActive?: boolean;
     leanTurboCurrentPhase?: number;
-    epicModeActive?: boolean;
+    /**
+     * Frozen legacy field (Epic v1 per-session flag). Epic v2 is plan-scoped
+     * and has no session field; the writer keeps emitting the constant
+     * `false` so non-Epic snapshot JSON stays byte-identical, and the reader
+     * ignores the value. See {@link LEGACY_SERIALIZED_ONLY_FIELDS}.
+     */
+    epicModeActive?: false;
     gateLog: Record<string, string[]>;
     reviewerCallCount: Record<string, number>;
     lastGateFailure: {
@@ -145,7 +151,12 @@ export declare const SESSION_TRANSIENT_FIELDS: Readonly<Record<Exclude<keyof Age
  * state counterpart, the type degrades to the error tuple below and assigning
  * `true` fails `bun run typecheck` with that message.
  */
-export type SerializedFieldsAllExistOnState = Exclude<keyof SerializedAgentSession, keyof AgentSessionState> extends never ? true : ['SerializedAgentSession field missing from AgentSessionState'];
+/**
+ * Serialized fields kept only for byte-stable snapshot JSON, with no live
+ * session counterpart (written as a constant, ignored on read).
+ */
+export type LEGACY_SERIALIZED_ONLY_FIELDS = 'epicModeActive';
+export type SerializedFieldsAllExistOnState = Exclude<keyof SerializedAgentSession, keyof AgentSessionState | LEGACY_SERIALIZED_ONLY_FIELDS> extends never ? true : ['SerializedAgentSession field missing from AgentSessionState'];
 export declare const _serializedFieldsExistOnState: SerializedFieldsAllExistOnState;
 /**
  * Minimal interface for serialized InvocationWindow

package/dist/state.d.ts

@@ -424,11 +424,6 @@ export interface AgentSessionState {
      *  When set, overrides the plan's execution_profile.max_concurrent_tasks
      *  for delegation-gate guidance. Cleared on session reset. */
     maxConcurrencyOverride?: number;
-    /** Whether Epic Mode (additive overlay above Lean Turbo) is active for
-     *  this session. Durable mirror lives in `.swarm/epic-state.json`; this
-     *  in-memory flag matches what `src/turbo/epic/state.ts` persists and is
-     *  what `hasActiveEpicMode(sessionID)` reads on the hot path. */
-    epicModeActive?: boolean;
     /** Session-scoped override for execution_profile.auto_proceed.
      *  When set, overrides the plan's auto_proceed for this session.
      *  true = auto-advance, false = do not auto-advance. Cleared on session reset. */
@@ -1173,6 +1168,13 @@ export declare function maybeSweepStaleSessions(staleDurationMs?: number, now?:
  * constructions (e.g. the recovery session) and any config-read failure
  * default to false. `/swarm turbo` remains the per-session authority after
  * construction.
+ *
+ * Epic seam: while an epic is open for the project's current plan
+ * (`isEpicOpenForProject` — config-gated and identity-checked) config
+ * cannot seed Turbo on, because Turbo waives per-task QA that Epic never
+ * waives. The sentinel is probed only when config would otherwise seed
+ * `true`, so the common path does no extra I/O and a project without an
+ * open epic gets the identical result.
  */
 export declare function resolveInitialTurboMode(directory?: string): boolean;
 export declare function startAgentSession(sessionId: string, agentName: string, staleDurationMs?: number, directory?: string): void;
@@ -1348,8 +1350,12 @@ export declare function resetModifiedFilesForTask(session: AgentSessionState, ta
 /**
  * Apply task-completion retention rules.
  *
- * Non-Epic sessions release attribution at the workflow-complete boundary.
- * Epic sessions retain it until `epic_record_divergence` consumes the entry.
+ * Attribution is released at the workflow-complete boundary, except while an
+ * epic is open for the session's project: then it is retained until its
+ * wave closes (`epic_next_wave` → `wave-close.ts` reads it for divergence
+ * and releases it). The project comes from the session's owning project key
+ * (a canonical root path); an unowned session is treated as non-Epic. With
+ * no epic the probe costs one `existsSync`.
  */
 export declare function completeModifiedFilesForTask(session: AgentSessionState, taskId: string): void;
 export declare function updateTaskWorkflowCache(session: AgentSessionState, taskId: string, overrides: Partial<TaskWorkflowCacheEntry>): void;
@@ -1547,16 +1553,6 @@ export declare function getActiveFullAutoSessionID(): string | undefined;
  *          or if any session has that combination when no sessionID provided.
  */
 export declare function hasActiveLeanTurbo(sessionID?: string): boolean;
-/**
- * Check if Epic Mode is active for a specific session or ANY session.
- * Mirrors `hasActiveLeanTurbo` but reads `session.epicModeActive`. The flag
- * is set by `enableEpicMode` (and by `/swarm turbo epic on`) and cleared by
- * `disableEpicMode` (and `/swarm turbo epic off`). The durable mirror is
- * `.swarm/epic-state.json` — see `src/turbo/epic/state.ts`. Epic Mode does
- * NOT require `turboStrategy === 'lean'`; it composes Lean Turbo internally
- * inside `epic_run_phase`.
- */
-export declare function hasActiveEpicMode(sessionID?: string): boolean;
 /**
  * Resolves the effective auto_proceed value for a session.
  * Session override (autoProceedOverride) takes precedence over the plan default.
@@ -1730,7 +1726,6 @@ export declare const _internals: {
     hasActiveFullAuto: typeof hasActiveFullAuto;
     hasActiveTurboMode: typeof hasActiveTurboMode;
     hasActiveLeanTurbo: typeof hasActiveLeanTurbo;
-    hasActiveEpicMode: typeof hasActiveEpicMode;
     buildRehydrationCache: typeof buildRehydrationCache;
     applyRehydrationCache: typeof applyRehydrationCache;
     rehydrateSessionFromDisk: typeof rehydrateSessionFromDisk;

package/dist/tools/epic-next-wave.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Epic Mode `epic_next_wave` tool (Epic v2 C2) — architect-only, gated by
+ * `epic.mode.enabled` through `EPIC_AGENT_TOOL_MAP`.
+ *
+ * The single way forward while an epic is open: it closes the active wave
+ * when every task is resolved (recording outcomes and divergence), keeps
+ * phases in order, and issues the next wave with dispatch instructions.
+ * Idempotent: calling it again while a wave runs returns `in-progress` for
+ * the same wave. See `src/epic/next-wave.ts` for the full contract.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { runEpicNextWave } from '../epic/next-wave.js';
+/**
+ * DI seam (AGENTS.md invariant 7); restore in afterEach.
+ * @tool-opt-out Test-only dependency-injection seam; not a public tool.
+ */
+export declare const _internals: {
+    runEpicNextWave: typeof runEpicNextWave;
+};
+export declare const epic_next_wave: ToolDefinition;

package/dist/tools/epic-phase-review.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Epic Mode phase review tool (`epic_phase_review`).
+ *
+ * Satisfies the `epic_phase_readiness` gate in `phase_complete`. The tool —
+ * not the architect — dispatches a read-only phase reviewer and, when the
+ * reviewer APPROVES, a read-only phase critic through the plugin-owned review
+ * dispatcher, parses each verdict from the agent's own response, and records
+ * both to `.swarm/evidence/{phase}/epic-phase-review.json` bound to the
+ * current plan / phase task state. See `src/epic/phase-readiness.ts`.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import { getOpenEpic, isEpicOpenForProject, updateEpicRecord } from '../epic/lifecycle.js';
+import { describeOpenEpicWaves, type EpicPhaseReviewRunResult, resolveEpicPhaseReviewTimeoutMs, runEpicPhaseReview } from '../epic/phase-readiness.js';
+import type { ReviewModelDispatcher } from '../review/contracts.js';
+import type { ReviewAgentModelRegistry } from '../review/runtime.js';
+export type EpicPhaseReviewToolResult = EpicPhaseReviewRunResult | {
+    success: false;
+    phase: number;
+    reason: 'epic-mode-not-active' | 'no-session' | 'invalid-phase' | 'waves-open';
+    message: string;
+};
+/**
+ * DI seam (AGENTS.md invariant 7); restore in afterEach.
+ * @tool-opt-out Test-only dependency-injection seam; not a public tool.
+ */
+export declare const _internals: {
+    runEpicPhaseReview: typeof runEpicPhaseReview;
+    resolveEpicPhaseReviewTimeoutMs: typeof resolveEpicPhaseReviewTimeoutMs;
+    isEpicOpenForProject: typeof isEpicOpenForProject;
+    describeOpenEpicWaves: typeof describeOpenEpicWaves;
+    getOpenEpic: typeof getOpenEpic;
+    updateEpicRecord: typeof updateEpicRecord;
+};
+export declare function executeEpicPhaseReview(args: {
+    phase: number;
+}, directory: string, sessionID: string | undefined, options?: {
+    dispatcher?: ReviewModelDispatcher;
+    generatedAgentNames?: readonly string[];
+    agentModelRegistry?: ReviewAgentModelRegistry;
+    activeAgentName?: string;
+}): Promise<EpicPhaseReviewToolResult>;
+export declare function createEpicPhaseReviewTool(dispatcher?: ReviewModelDispatcher, generatedAgentNames?: readonly string[], agentModelRegistry?: ReviewAgentModelRegistry, getActiveAgentName?: (sessionID: string) => string | undefined): ToolDefinition;
+export declare const epic_phase_review: ToolDefinition;

package/dist/tools/index.d.ts

@@ -104,9 +104,8 @@ export { approve_retry_sounding_board, executeApproveRetrySoundingBoard, } from
 export { authorize_pr_review_reentry } from './authorize-pr-review-reentry';
 export { CancelLaneBatchArgsSchema, cancel_lane_batch, executeCancelLaneBatch, } from './cancel-lane-batch';
 export { complete_pr_workflow, executeCompletePrWorkflow, } from './complete-pr-workflow';
-export { epic_plan_waves } from './epic-plan-waves';
-export { epic_record_divergence } from './epic-record-divergence';
-export { epic_decide_phase } from './epic-run-phase';
+export { epic_next_wave } from './epic-next-wave';
+export { epic_phase_review } from './epic-phase-review';
 export { generate_mutants } from './generate-mutants';
 export { executeInvalidatePrFeedbackPublication, invalidate_pr_feedback_publication, } from './invalidate-pr-feedback-publication';
 export { lean_turbo_acquire_locks } from './lean-turbo-acquire-locks';

package/dist/tools/manifest.d.ts

@@ -160,7 +160,6 @@ export declare const TOOL_MANIFEST: {
     external_skill_reject: () => ToolDefinition;
     external_skill_delete: () => ToolDefinition;
     external_skill_revoke: () => ToolDefinition;
-    epic_decide_phase: () => ToolDefinition;
-    epic_plan_waves: () => ToolDefinition;
-    epic_record_divergence: () => ToolDefinition;
+    epic_next_wave: () => ToolDefinition;
+    epic_phase_review: () => ToolDefinition;
 };

package/dist/tools/phase-complete.d.ts

@@ -3,7 +3,8 @@
  * Core implementation - gathers data, enforces policy, writes event, resets state.
  */
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
-import { savePlan } from '../plan/manager';
+import { isEpicOpenForProject, markEpicPhaseComplete } from '../epic/lifecycle';
+import { verifyEpicPhaseReadiness } from '../epic/phase-readiness';
 import type { ReviewModelDispatcher } from '../review/contracts.js';
 import type { ReviewAgentModelRegistry } from '../review/runtime.js';
 import { runArchitectureSupervisorGate, runCompletionVerifyGate, runDriftGate, runFinalCouncilGate, runFinalReviewGate, runHallucinationGate, runMutationGate, runPhaseCouncilGate, runTodoGateGate } from './phase-complete/gates/index.js';
@@ -105,6 +106,7 @@ export declare const phaseCompleteCommitInternals: {
         };
         preCommitCheck?: () => void;
     } | undefined) => Promise<import("../plan").PlanSaveDurability>;
+    markEpicPhaseComplete: typeof markEpicPhaseComplete;
 };
 /** Injectable observational gates for aggregate-preflight regression tests. */
 export declare const phaseCompletePreflightInternals: {
@@ -117,6 +119,8 @@ export declare const phaseCompletePreflightInternals: {
     runFinalReviewGate: typeof runFinalReviewGate;
     runFinalCouncilGate: typeof runFinalCouncilGate;
     runTodoGateGate: typeof runTodoGateGate;
+    verifyEpicPhaseReadiness: typeof verifyEpicPhaseReadiness;
+    isEpicOpenForProject: typeof isEpicOpenForProject;
 };
 /**
  * Arguments for the phase_complete tool

package/dist/tools/save-plan.d.ts

@@ -5,6 +5,7 @@
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
 import { loadPluginConfigWithMeta } from '../config';
 import { type ExecutionProfile } from '../config/plan-schema';
+import { computeSavePlanEpicShaping, type EpicSavePlanShaping } from '../epic/plan-shaping-seam.js';
 import { takeSnapshotWithRetry } from '../plan/ledger';
 /**
  * DI seam for hermetic config-load substitution in tests (AGENTS.md invariant 7).
@@ -16,6 +17,7 @@ import { takeSnapshotWithRetry } from '../plan/ledger';
  */
 export declare const _internals: {
     loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+    computeSavePlanEpicShaping: typeof computeSavePlanEpicShaping;
 };
 /** Test seam for the snapshot retry helper (FR-004). */
 export declare const _test_exports: {
@@ -116,6 +118,11 @@ export interface SavePlanResult {
     requirement_coverage?: RequirementCoverageResult;
     /** The resolved execution_profile that was persisted, if any. */
     execution_profile?: ExecutionProfile;
+    /**
+     * Epic v2 C7 plan-shaping advisory — present only when
+     * `epic.mode.enabled` is true and no epic is open.
+     */
+    epic_shaping?: EpicSavePlanShaping;
 }
 interface RequirementCoverageEntry {
     id: string;

package/dist/tools/tool-metadata.d.ts

@@ -673,17 +673,13 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: never[];
     };
-    epic_decide_phase: {
+    epic_next_wave: {
         description: string;
-        agents: "architect"[];
-    };
-    epic_plan_waves: {
-        description: string;
-        agents: "architect"[];
+        agents: never[];
     };
-    epic_record_divergence: {
+    epic_phase_review: {
         description: string;
-        agents: "architect"[];
+        agents: never[];
     };
 };
 /** Union type of all valid tool names (the metadata keys). */

package/dist/worktree/merge.d.ts

@@ -203,6 +203,17 @@ export interface DirtyMergeOptions {
      * `'rebase'` and `'cherry-pick'` always land committed regardless.
      */
     commitLanding?: boolean;
+    /**
+     * Epic v2 C3: message of the committed landing (only with
+     * `commitLanding` on a `'merge'` dispatch). When set, the lane lands as
+     * an explicit merge commit carrying this message (`git -c
+     * commit.gpgsign=false merge --no-ff --no-edit --no-verify -m <message>`)
+     * so the landing is identifiable in history. It is a protocol commit on
+     * the epic branch: repository commit hooks and signing apply when the
+     * user commits the epic's squash at close. Absent ⇒ the plain
+     * `git merge --no-edit` landing.
+     */
+    landingCommitMessage?: string;
     /**
      * Awaited after auto-commit and HEAD capture, but before the Git merge.
      * A rejection fails closed without invoking the merge.
@@ -274,7 +285,9 @@ export declare function getMergeStrategy(config: {
  * @param strategy   - Merge strategy to use.
  * @returns Discriminated union: success, conflict, or failure.
  */
-export declare function mergeLaneBranch(primaryDir: string, branchName: string, strategy: MergeStrategy): Promise<MergeSuccess | MergeConflict | MergeFailure>;
+export declare function mergeLaneBranch(primaryDir: string, branchName: string, strategy: MergeStrategy, 
+/** Epic v2 C3: explicit merge-commit message (see `DirtyMergeOptions`). */
+commitMessage?: string): Promise<MergeSuccess | MergeConflict | MergeFailure>;
 /**
  * Re-applies a preserved lane using exact immutable object ids captured by the
  * #2105 recovery authority.