opencode-swarm 7.188.12 → 7.190.0

package/dist/epic/declared-scopes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Epic Mode declared-scope resolution (v2 binding store only).
+ *
+ * `declare_scope` persists ONLY v2 scope bindings in the authoritative
+ * coordination store; nothing in production writes the legacy v1
+ * `.swarm/scopes/scope-<taskId>.json` projection any more. Every Epic
+ * scheduling consumer (`epic_next_wave`, the `/swarm epic start` sizing
+ * preview, `/swarm coupling`) therefore resolves declared scopes
+ * here, using the same upstream readers `src/plan/parallel-verdict.ts` uses:
+ *
+ *   - ONE `readAuthoritativeScopeBindingSet` scan per call (#2532 hoisting),
+ *   - `readDeclaredScopeFilesFromBindings` per task, pinned to the exact plan
+ *     identity (`planId` + `planStructureHash`), live + unexpired only.
+ *
+ * The result maps EVERY requested task id to a file list — `[]` when the task
+ * has no live, agreeing, non-empty binding (undeclared, expired, declared
+ * against an older plan revision, store unreadable/overloaded, or no plan).
+ * Passing that map as the explicit `scopes` argument of the shared partition
+ * preflight (`runPartitionPreflight`) guarantees the preflight never falls
+ * back to its own v1 file read for an Epic task: upstream treats an explicit
+ * `[]` entry as "effectively undeclared", which then takes exactly the
+ * `files_touched` fallback that `require_declared_scope` permits — the same
+ * semantics the preflight applies to an undeclared task.
+ *
+ * Nothing here is write authority: these are scheduling reads.
+ */
+import type { Plan } from '../config/plan-schema.js';
+/**
+ * Resolve the live declared scope of each task from the v2 binding store.
+ *
+ * @param directory - Project root (binding-store location).
+ * @param plan - The plan the scopes must be pinned to. `null` (unreadable /
+ *        invalid plan) resolves every task to `[]` without touching the store.
+ * @param taskIds - Tasks to resolve. Every id appears in the result.
+ * @returns `taskId -> files` (`[]` = no live declared scope).
+ */
+export declare function resolveEpicDeclaredScopes(directory: string, plan: Plan | null, taskIds: readonly string[]): Record<string, string[]>;

package/dist/epic/epic-branch.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Epic branch (Epic v2 C1b): the `epic-branch` commit policy.
+ *
+ * With `epic.commit_policy: 'epic-branch'` (the default) a git epic
+ * runs on its own branch `swarm/epic/<epicKey>`:
+ *   - `/swarm epic start` checks it out (`git checkout -b`) right after the
+ *     lifecycle row is created; the record names it only once the checkout
+ *     succeeded (M-e).
+ *   - every Epic step that commits or plans against HEAD first verifies HEAD
+ *     is still that branch ({@link checkEpicBranch} → EPIC_BRANCH_MISMATCH,
+ *     fail closed) — the user may have checked out something else meanwhile.
+ *   - `/swarm epic close` lands it back onto the original branch
+ *     (`--land squash|merge|none`, default squash: staged, UNCOMMITTED
+ *     changes the user reviews and commits). The epic branch itself is never
+ *     deleted by the plugin.
+ *
+ * Read-only git calls go through `gitExec` (`src/git/branch.ts`: array argv,
+ * explicit cwd, closed stdin, timeout, bounded output, GIT_TERMINAL_PROMPT=0).
+ * State-changing calls (checkout -b, checkout, merge, merge --squash,
+ * reset --merge, merge --abort, branch -D) go through `gitExecOnce`
+ * (`./git-once.ts`): the same spawn primitive and hardening but WITHOUT
+ * `gitExec`'s transient (ETIMEDOUT) retry — re-running a non-idempotent
+ * command after a timeout whose effect may already have happened would
+ * misreport the state. Callers inspect the actual repository state after any
+ * failure instead.
+ * Landing additionally pins a non-interactive editor (`GIT_EDITOR=true`,
+ * `GIT_MERGE_AUTOEDIT=no`, `--no-edit`) and disables commit signing for the
+ * `--land merge` commit, so no merge can wait on an editor or a pinentry.
+ * Repository hooks (pre-merge-commit, commit-msg) still run with stdin
+ * closed; a hook that rejects the merge is a landing failure, rolled back
+ * with `git merge --abort`.
+ */
+import { type EpicConfigSource } from './config.js';
+import { gitExecOnce } from './git-once.js';
+import type { EpicCommitPolicy, EpicLandMode, EpicRecordV1 } from './lifecycle.js';
+/** Branch namespace of every epic branch. */
+export declare const EPIC_BRANCH_PREFIX = "swarm/epic/";
+export declare const DEFAULT_EPIC_COMMIT_POLICY: EpicCommitPolicy;
+export declare const DEFAULT_EPIC_LAND_MODE: EpicLandMode;
+/**
+ * DI seam (AGENTS.md invariant 7). Restore in `afterEach`.
+ */
+export declare const _internals: {
+    gitExec: (args: string[], cwd: string, env?: Record<string, string>) => string;
+    /** State-changing git commands: one attempt, no transient retry. */
+    gitExecOnce: typeof gitExecOnce;
+};
+/** `epic.commit_policy`, defaulting to `epic-branch`. */
+export declare function resolveEpicCommitPolicy(config: EpicConfigSource): EpicCommitPolicy;
+/** `swarm/epic/<epicKey>`; fail-closed against option injection. */
+export declare function epicBranchName(epicKey: string): string;
+/**
+ * Paths with uncommitted changes outside `.swarm/` (tracked or untracked).
+ * Throws when git fails. `exec` lets the start module keep its own seam.
+ */
+export declare function listDirtyPathsOutsideSwarm(directory: string, exec?: (args: string[], cwd: string) => string): string[];
+/**
+ * The checked-out branch name, or null for a detached HEAD. Throws when git
+ * fails (including an unborn branch, which has no commit to branch from).
+ */
+export declare function readCurrentBranch(directory: string): string | null;
+/** True when the local branch exists. Throws when git fails. */
+export declare function localBranchExists(directory: string, branch: string): boolean;
+/** `git checkout -b <branch>` from the current HEAD. Throws git's stderr. */
+export declare function checkoutNewEpicBranch(directory: string, branch: string): void;
+/** `git checkout <branch>`. Throws git's stderr. */
+export declare function checkoutExistingBranch(directory: string, branch: string): void;
+/**
+ * Best-effort undo of a just-created epic branch (start rollback), driven
+ * by the ACTUAL repository state (a failed or timed-out `checkout -b` may
+ * or may not have created the branch / switched HEAD): switch back to the
+ * original branch when HEAD is on the epic branch, then delete the epic
+ * branch only while its tip is still `baseCommit` (no work on it). Returns
+ * the problems, if any, for the refusal text.
+ */
+export declare function undoEpicBranchCreate(directory: string, originalBranch: string, branch: string, baseCommit: string): string[];
+export type EpicBranchCheck = {
+    ok: true;
+} | {
+    ok: false;
+    code: 'EPIC_BRANCH_MISMATCH';
+    expected: string | null;
+    actual: string | null;
+    message: string;
+};
+/**
+ * Branch-drift guard (M-e): under the epic-branch policy HEAD must be the
+ * recorded epic branch. One `git rev-parse --abbrev-ref HEAD`; a git failure
+ * or an unrecorded branch fails closed. Current-branch / non-git epics
+ * always pass.
+ */
+export declare function checkEpicBranch(directory: string, record: EpicRecordV1): EpicBranchCheck;
+export type EpicLandingRefusal = 'dirty-worktree' | 'epic-branch-missing' | 'original-branch-missing' | 'detached-head' | 'git-failed';
+export type EpicLandingPreflight = {
+    kind: 'not-applicable';
+    detail: string;
+} | {
+    kind: 'already-landed';
+    detail: string;
+}
+/** On the original branch and the epic branch has no changes: no git work. */
+ | {
+    kind: 'nothing-to-land';
+    detail: string;
+} | {
+    kind: 'ready';
+    currentBranch: string | null;
+    nothingToLand: boolean;
+} | {
+    kind: 'refused';
+    reason: EpicLandingRefusal;
+    details: string[];
+};
+/** Where the repository actually ended up after a landing attempt. */
+export interface EpicLandingAfterState {
+    branch: string | null;
+    /** No changes outside `.swarm/` and no merge in progress. */
+    clean: boolean;
+}
+export interface EpicLandingResult {
+    status: 'landed' | 'nothing-to-land' | 'conflict' | 'failed';
+    conflictFiles: string[];
+    detail: string;
+    after: EpicLandingAfterState;
+}
+/** Branch pair of an epic-branch epic, or null when there is nothing to land. */
+export declare function epicBranchPair(record: EpicRecordV1): {
+    epicBranch: string;
+    originalBranch: string;
+} | null;
+/**
+ * Read-only landing preflight, run BEFORE the close marks the row `closing`
+ * (M-f). Refuses a dirty tree, a missing epic/original branch, and a
+ * detached HEAD whose commits are on neither branch; detects an
+ * already-landed (or nothing-to-land) state so a resumed close is idempotent.
+ */
+export declare function preflightEpicLanding(directory: string, record: EpicRecordV1, mode: EpicLandMode): EpicLandingPreflight;
+/**
+ * Land the epic branch per `mode` after a `ready` preflight: check out the
+ * original branch, then squash (staged, uncommitted) / merge (`--no-ff`
+ * merge commit) / nothing. On a conflict the attempt is rolled back —
+ * squash with `git reset --merge` (a squash writes no MERGE_HEAD, so
+ * `merge --abort` cannot be used), merge with `git merge --abort` — and the
+ * result reports where the repository actually ended up.
+ */
+export declare function performEpicLanding(directory: string, record: EpicRecordV1, mode: EpicLandMode, preflight: Extract<EpicLandingPreflight, {
+    kind: 'ready';
+}>): EpicLandingResult;
+/**
+ * `--abandon` (and `/swarm close` finalization, MINOR 3): never land; switch
+ * back to the original branch when the tree is clean and no detached commit
+ * would be orphaned, so the epic branch is not left checked out. Never throws.
+ */
+export declare function leaveEpicBranchOnAbandon(directory: string, record: EpicRecordV1): {
+    status: 'checked-out-original' | 'left-in-place';
+    detail: string;
+};

package/dist/epic/gate-policy.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Epic v2 C4 — the delegation gate's single source of truth while an epic is
+ * open: coder dispatch is admitted ONLY for a task of the ACTIVE wave, and
+ * the wave's parallelism is decided from the scopes FROZEN into the wave
+ * record when `epic_next_wave` issued it (never from live bindings, which
+ * expire and follow plan revisions — critic M4).
+ *
+ * {@link computeEpicWaveVerdict} is THE verdict call: `epic_next_wave`
+ * asserts it is `all_disjoint` before it issues a multi-task wave, and the
+ * gate recomputes exactly the same call over the wave's unresolved tasks
+ * to decide `parallel`. The two can therefore never disagree.
+ *
+ * {@link resolveEpicDispatchPolicy} returns `null` when no epic is open for
+ * the current plan — the gate then runs its normal (non-Epic) logic,
+ * untouched. The gate calls it only after its own synchronous sentinel
+ * check (one `existsSync`), so Epic-off costs nothing more. Everything here
+ * is synchronous: no await, no microtask.
+ *
+ * Out of scope by construction (documented in docs/modes.md): PR-feedback
+ * coders (the gate returns before this seam — they carry no plan task), and
+ * reviewer / test_engineer / other agents (never routed through coder
+ * admission).
+ */
+import type { Plan } from '../config/plan-schema.js';
+import { type ComputeParallelVerdictOptions, computeParallelVerdict as computeParallelVerdict_import, type ParallelVerdict } from '../plan/parallel-verdict.js';
+import { isEpicModeConfigEnabledForDirectory as isEpicModeConfigEnabledForDirectory_import } from './config-gate.js';
+import { checkEpicBranch as checkEpicBranch_import } from './epic-branch.js';
+import { type EpicWaveRecord, epicSentinelExists as epicSentinelExists_import, getOpenEpic as getOpenEpic_import, inspectEpic as inspectEpic_import } from './lifecycle.js';
+/** DI seam (AGENTS.md invariant 7). Restore in `afterEach`. */
+export declare const _internals: {
+    epicSentinelExists: typeof epicSentinelExists_import;
+    isEpicModeConfigEnabledForDirectory: typeof isEpicModeConfigEnabledForDirectory_import;
+    getOpenEpic: typeof getOpenEpic_import;
+    inspectEpic: typeof inspectEpic_import;
+    checkEpicBranch: typeof checkEpicBranch_import;
+    computeParallelVerdict: typeof computeParallelVerdict_import;
+};
+export type EpicDispatchRejectCode = 'EPIC_NO_ACTIVE_WAVE' | 'EPIC_TASK_NOT_IN_ACTIVE_WAVE' | 'EPIC_TASK_UNKNOWN' | 'EPIC_WAVE_SCOPE_DRIFT' | 'EPIC_STATE_UNREADABLE' | 'EPIC_CLOSING' | 'EPIC_BRANCH_MISMATCH';
+export type EpicDispatchPolicy = {
+    kind: 'allow';
+    /** Concurrent coders of this wave are allowed (slot cap = maxConcurrent). */
+    parallel: boolean;
+    /** The coder runs in an isolated git worktree (degradation refused). */
+    isolate: boolean;
+    /** The epic's wave width (`record.config.maxParallel`). */
+    maxConcurrent: number;
+} | {
+    kind: 'reject';
+    code: EpicDispatchRejectCode;
+    message: string;
+};
+/** The frozen part of a wave the verdict is computed from. */
+export type EpicWaveScopes = Pick<EpicWaveRecord, 'files' | 'cochange'>;
+/** The verdict options for a wave's frozen scopes (exported for parity tests). */
+export declare function epicWaveVerdictOptions(plan: Plan, wave: EpicWaveScopes): ComputeParallelVerdictOptions;
+/**
+ * THE wave verdict: `computeParallelVerdict` over `taskIds` with the wave's
+ * frozen scopes (and frozen co-change pairs when the wave recorded them).
+ * Used by `epic_next_wave` at issue and by the gate at dispatch.
+ */
+export declare function computeEpicWaveVerdict(directory: string, plan: Plan, wave: EpicWaveScopes, taskIds: string[]): ParallelVerdict;
+/**
+ * The open epic's dispatch policy for a coder of `incomingTaskId` whose
+ * live declared scope is `liveBindingFiles`; `null` when no epic is open for
+ * this plan (sentinel absent, no open row, Epic disabled by config, or the
+ * epic is orphaned/closing).
+ */
+export declare function resolveEpicDispatchPolicy(directory: string, plan: Plan, incomingTaskId: string | null | undefined, liveBindingFiles: readonly string[] | null | undefined): EpicDispatchPolicy | null;
+export type EpicGateAttribution = 
+/** No open epic, no active wave, or a single-task wave: upstream behaviour. */
+{
+    kind: 'none';
+}
+/** Exactly one task of the active wave owns every checked file. */
+ | {
+    kind: 'task';
+    taskId: string;
+}
+/** Fail closed: credit no task, and tell the architect why. */
+ | {
+    kind: 'unattributable';
+    message: string;
+};
+/**
+ * The wave task a gate-tool run (`pre_check_batch`, …) belongs to while an
+ * epic is open.
+ *
+ * Upstream credits a gate run to the session's single `currentTaskId`, which
+ * holds whichever coder returned last. In a multi-task wave every Stage A run
+ * would then be credited to that one task: the task whose files were checked
+ * never reaches Stage B, and another task gets credit for a check it never
+ * had. Epic knows each wave task's frozen scope, so it credits the run to the
+ * ONE active-wave task whose frozen scope contains every checked file
+ * (containment as the write gates enforce it: a frozen directory covers the
+ * files beneath it). No files, no owner, several owners, or unreadable epic
+ * state credit nothing (fail closed). Sentinel-first: one `existsSync` when
+ * Epic is off.
+ */
+export declare function resolveEpicGateTaskAttribution(directory: string, files: readonly string[] | null): EpicGateAttribution;
+export type EpicPrFeedbackConflict = {
+    code: 'EPIC_PR_FEEDBACK_SCOPE_OVERLAP' | 'EPIC_STATE_UNREADABLE';
+    message: string;
+};
+/**
+ * Review F-007: a PR-feedback coder is admitted outside the wave gate (its
+ * authority is the authenticated PR-feedback declaration, not a plan task),
+ * so nothing stopped it from writing files a running wave task owns. While
+ * an epic has an ISSUED wave, refuse a PR-feedback coder whose declared files
+ * overlap any of that wave's frozen task scopes — in either direction (a
+ * declared directory that contains a frozen file overlaps too). Null when
+ * there is no overlap, no issued wave, or no open epic; unreadable epic state
+ * fails closed. Sentinel-first: one `existsSync` when Epic is off.
+ */
+export declare function resolveEpicPrFeedbackConflict(directory: string, declaredFiles: readonly string[] | null | undefined): EpicPrFeedbackConflict | null;

package/dist/epic/git-once.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Single-attempt git primitives for Epic's state-changing commands.
+ *
+ * `gitExec` (`src/git/branch.ts`) retries transient spawn failures, which is
+ * right for reads but wrong for a command whose effect may already have
+ * happened when it timed out (checkout, merge, commit, update-ref): running
+ * it again would misreport the state. Epic therefore runs every
+ * state-changing git command exactly once through {@link gitExecOnce} — the
+ * same spawn seam and hardening as `gitExec` (array argv, explicit cwd,
+ * closed stdin, timeout, bounded output, `GIT_TERMINAL_PROMPT=0`) without
+ * the retry — and callers inspect the real repository state after a failure.
+ *
+ * {@link gitProbeExitCode} answers yes/no questions git encodes in its exit
+ * status (`merge-base --is-ancestor`): 0 and 1 are answers, anything else
+ * (or a spawn error) throws.
+ */
+/**
+ * One bounded, non-interactive git spawn with NO transient retry. Throws
+ * git's stderr (or the spawn error) on failure.
+ */
+export declare function gitExecOnce(args: string[], cwd: string, env?: Record<string, string>): string;
+/**
+ * Exit status of a read-only git question (0 = yes, 1 = no). Throws on a
+ * spawn error, a timeout, or any other exit status.
+ */
+export declare function gitProbeExitCode(args: string[], cwd: string): 0 | 1;

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

@@ -0,0 +1,176 @@
+/**
+ * Epic v2 C6 — persistence of what epics learn (`learning.ts` is the math).
+ *
+ * Two levels:
+ *   - the PROJECT PRIOR `.swarm/epic-prior/learning.json` (schema
+ *     `epic-learning-v1`, paths and numbers only). It lives outside
+ *     `.swarm/epic/`, so it survives `/swarm close` (not in
+ *     `ACTIVE_STATE_DIRS_TO_CLEAN`); `/swarm epic prior reset`
+ *     clears it;
+ *   - the EPIC POSTERIOR `.swarm/epic/posterior.json` (schema
+ *     `epic-posterior-v1`): at `/swarm epic start` a copy of the prior
+ *     (`base`, whose digest the epic record keeps as `priorDigest`) plus the
+ *     `increments` learned from this epic's closed waves. Every wave close
+ *     applies the outcomes of each closed wave with a seq above
+ *     `lastAppliedWaveSeq` exactly once (idempotent per wave; a crash between
+ *     the close and the update is caught up by the next update or the close).
+ *     At `/swarm epic close` (any outcome — also `/swarm close`'s
+ *     finalization) the prior becomes
+ *       bound(decay_per_epic × timeDecay(prior) ⊕ increments)
+ *     once per epic instance (`mergedEpics`, the newest 50 report keys); an
+ *     epic with no increments only marks itself merged (no decay).
+ *
+ * Planning reads the posterior of the open epic, else the prior, decayed by
+ * 0.5^floor(Δdays / half_life_days) since it was written (whole half-lives:
+ * full weight until a half-life has passed). An unreadable prior is
+ * never overwritten (planning runs without learned signals; the remedy is
+ * `/swarm epic prior reset`); an unreadable or foreign posterior
+ * is rebuilt from the prior and the epic record's outcomes.
+ *
+ * First start migration: Epic v1 `.swarm/epic/calibration.json`
+ * (`hotModuleAdditions` ⇒ α = 2) and `.swarm/epic/divergence.jsonl`
+ * (declared ⇒ exposures, undeclared ⇒ incidents + co-write edges, latest
+ * record per plan + task) are imported once into the prior, which records
+ * `importedFrom`; a reset keeps that marker (or writes a `reset` marker),
+ * so nothing is imported after an import or a reset. A `/swarm close`
+ * before the first start archives the v1 files away: nothing is imported.
+ *
+ * All writes are atomic `.swarm/`-contained writes; every state is bounded
+ * by `boundEpicLearning` (2000 files, 2000 edges).
+ */
+import { z } from 'zod';
+import { type EpicLearningSettings, type EpicLearningStats } from './learning.js';
+import type { EpicRecordV1 } from './lifecycle.js';
+export declare const EPIC_PRIOR_LEARNING_RELATIVE_PATH: string;
+/** The prior's path as shown to users (POSIX separators). */
+export declare const EPIC_PRIOR_LEARNING_DISPLAY_PATH = ".swarm/epic-prior/learning.json";
+export declare const EPIC_POSTERIOR_RELATIVE_PATH: string;
+/** Report keys of the epics already merged into the prior (newest kept). */
+export declare const EPIC_PRIOR_MERGED_EPICS_KEEP = 50;
+/** α seeded for each Epic v1 `hotModuleAdditions` entry. */
+export declare const EPIC_LEGACY_HOT_MODULE_ALPHA = 2;
+declare const importedFromSchema: z.ZodObject<{
+    at: z.ZodString;
+    source: z.ZodEnum<{
+        reset: "reset";
+        "epic-v1-import": "epic-v1-import";
+    }>;
+    calibrationHotModules: z.ZodNumber;
+    divergenceRecords: z.ZodNumber;
+}, z.core.$strict>;
+export type EpicPriorImport = z.infer<typeof importedFromSchema>;
+/** The persisted project prior, decoded. */
+export interface EpicPrior {
+    updatedAt: string;
+    importedFrom: EpicPriorImport | null;
+    mergedEpics: string[];
+    stats: EpicLearningStats;
+}
+export interface EpicPosterior {
+    epicKey: string;
+    token: string;
+    priorDigest: string | null;
+    createdAt: string;
+    lastAppliedWaveSeq: number;
+    base: {
+        updatedAt: string;
+        stats: EpicLearningStats;
+    };
+    increments: EpicLearningStats;
+}
+export type EpicPriorRead = {
+    status: 'absent';
+    digest: null;
+} | {
+    status: 'ok';
+    prior: EpicPrior;
+    digest: string;
+} | {
+    status: 'unreadable';
+    reason: string;
+    digest: null;
+};
+/** Read the project prior (no decay applied). Never throws. */
+export declare function readEpicPrior(directory: string): EpicPriorRead;
+/** Read the epic posterior; null when absent or unreadable. Never throws. */
+export declare function readEpicPosterior(directory: string): EpicPosterior | null;
+export type EpicLearningSource = 'posterior' | 'prior' | 'none' | 'prior-unreadable';
+/** Identifies one epic instance (`epicKey` repeats when a plan restarts). */
+export type EpicIdentity = Pick<EpicRecordV1, 'epicKey' | 'token'>;
+export interface EpicLearningView {
+    source: EpicLearningSource;
+    stats: EpicLearningStats;
+}
+/**
+ * What the planner learns from right now: the posterior of the open epic
+ * `epic` (time-decayed base ⊕ increments), else the time-decayed prior.
+ * An unreadable prior yields no learned signal (warned once). Never throws.
+ */
+export declare function loadEpicLearningView(directory: string, epic: EpicIdentity | null, settings: EpicLearningSettings, nowMs: number): EpicLearningView;
+/**
+ * `/swarm epic start`, after the epic was opened: the posterior starts as a
+ * copy of the prior snapshot the start read (its digest is the record's
+ * `priorDigest`). Throws on a write failure (the caller warns; the first
+ * wave close rebuilds it).
+ */
+export declare function initEpicPosterior(directory: string, record: Pick<EpicRecordV1, 'epicKey' | 'token' | 'priorDigest' | 'startedAt'>, snapshot: EpicPriorRead): void;
+export interface EpicWaveLearningResult {
+    /** Wave seqs whose outcomes this call applied (empty: nothing new). */
+    appliedWaves: number[];
+}
+/**
+ * Apply the outcomes of every CLOSED wave of `record` not applied yet
+ * (seq > `lastAppliedWaveSeq`) to the posterior — exactly once per wave.
+ * Throws on a write failure (the caller decides; the next call catches up).
+ */
+export declare function applyClosedWavesToPosterior(directory: string, record: EpicRecordV1, settings: EpicLearningSettings): EpicWaveLearningResult;
+export type EpicPriorMergeStatus = 'merged' | 'already-merged' | 'nothing-to-learn' | 'disabled' | 'prior-unreadable' | 'failed';
+export interface EpicPriorMergeResult {
+    status: EpicPriorMergeStatus;
+    /** Files / co-write edges this epic contributed. */
+    learnedFiles: number;
+    learnedEdges: number;
+    /** Hot files of the prior after the merge (≤ 10). */
+    hotFiles: string[];
+    detail: string;
+}
+/**
+ * `/swarm epic close` (any outcome): catch the posterior up with the
+ * record, then prior := bound(decay_per_epic × timeDecay(prior) ⊕
+ * increments), once per epic instance (`reportKey`). The posterior is
+ * removed afterwards. An epic that learned nothing leaves the statistics
+ * (and their write time) untouched and is only marked merged. Never throws.
+ */
+export declare function mergeEpicPosteriorIntoPrior(directory: string, record: EpicRecordV1, reportKey: string, settings: EpicLearningSettings, nowMs: number): EpicPriorMergeResult;
+export type EpicPriorResetResult = {
+    status: 'reset';
+    hadPrior: boolean;
+} | {
+    status: 'failed';
+    detail: string;
+};
+/**
+ * `/swarm epic prior reset`: the prior becomes empty. The
+ * `importedFrom` marker survives (a v1 import is never repeated); an open
+ * epic keeps its posterior and merges into the empty prior at close.
+ */
+export declare function resetEpicPrior(directory: string, nowMs: number): EpicPriorResetResult;
+export type EpicLegacyImportResult = {
+    status: 'imported';
+    calibrationHotModules: number;
+    divergenceRecords: number;
+} | {
+    status: 'already-imported' | 'nothing-to-import' | 'prior-unreadable';
+} | {
+    status: 'failed';
+    detail: string;
+};
+/**
+ * Import the Epic v1 learning files into the prior once (see the module
+ * header). Runs at `/swarm epic start`; writes only when there is
+ * something to import. Never throws.
+ */
+export declare function importLegacyEpicCalibrationOnce(directory: string, nowMs: number): EpicLegacyImportResult;
+/** One close-output line; always states that the project prior is kept. */
+export declare function describeEpicPriorMerge(result: EpicPriorMergeResult): string;
+export {};