dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/extraction-phase.js

@@ -1,236 +0,0 @@
-import { notifyMemoryExtraction } from "./notify.js";
-import { mergeHarnessStates } from "./state.js";
-import { projectKeyOf } from "./project.js";
-import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
-import { compareReviewCursors, sliceTurnSnapshot } from "./turn-snapshot.js";
-import { matchDeclinedTrajectory } from "./declines.js";
-import { runMemoryAgent, } from "./memory-agent.js";
-import { applyMemoryExtractionProposal } from "./memory-apply.js";
-import { buildMemoryManifest } from "./memory-manifest.js";
-import { DEFAULT_REVIEWS_RETAIN } from "./types.js";
-import { resolveRecordLanguage } from "./record-language.js";
-export function stateFor(map, sessionId) {
-    let state = map.get(sessionId);
-    if (!state) {
-        state = {
-            turns: 0,
-            completedTurn: 0,
-            memoryDecisions: {},
-            lastReviewAt: 0,
-            goalBlockStreak: 0,
-        };
-        map.set(sessionId, state);
-    }
-    return state;
-}
-export function advanceMemoryCheckpoint(state, next) {
-    if (state.memoryCheckpoint === undefined) {
-        state.memoryCheckpoint = next;
-        return;
-    }
-    const order = compareReviewCursors(next, state.memoryCheckpoint);
-    if (order === undefined || order > 0)
-        state.memoryCheckpoint = next;
-}
-function rememberMemoryDecision(state, key, decision) {
-    state.memoryDecisions[key] = decision;
-    const keys = Object.keys(state.memoryDecisions);
-    while (keys.length > 128)
-        delete state.memoryDecisions[keys.shift() ?? ""];
-}
-/**
- * The state view the extractor judges: the session's local entries merged
- * with the project and global stores, each entry carrying its real scope.
- * Without the global half the extractor cannot see that a topic is already
- * covered cross-session and happily re-sediments a local duplicate of it.
- *
- * The merged view is read-only context — applying still targets the raw
- * local state (baseline checks compare local entries only).
- */
-export function loadGateHarnessView(engine, sessionId, opts) {
-    const projectState = opts?.projectKey ? engine.load("project", opts.projectKey) : undefined;
-    return mergeHarnessStates(engine.load("global", undefined), engine.load("local", sessionId), projectState ? { projectState } : undefined);
-}
-/**
- * Gap C1: parse a "provider/model" or "model" string into its components.
- * Returns undefined when the input is empty (no override). A bare model name
- * falls back to the agent's provider, then "deepseek".
- * Exported for unit testing; production resolves it inside
- * runMemoryExtractionPhase.
- */
-export function parseReviewModel(reviewModel, fallbackProvider) {
-    if (!reviewModel || reviewModel.trim().length === 0)
-        return undefined;
-    const slash = reviewModel.indexOf("/");
-    if (slash > 0) {
-        return { provider: reviewModel.slice(0, slash), model: reviewModel.slice(slash + 1) };
-    }
-    return { provider: fallbackProvider ?? "deepseek", model: reviewModel };
-}
-/**
- * One extraction run over a scheduler snapshot. Records noop / applied /
- * declined audit rows with duration and loop stats, advances the memory
- * checkpoint on settled outcomes, and queues a visible receipt only for an
- * applied goal-blocked moment (compaction and session-close stay audit-only).
- */
-export async function runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, record, signal) {
-    const sessionId = agent.id;
-    const turnsSinceLastReview = state.turns - state.lastReviewAt;
-    // This invocation becomes the new reference point for the next audit row.
-    state.lastReviewAt = state.turns;
-    const startedAt = Date.now();
-    const memorySnapshot = state.memoryCheckpoint ? sliceTurnSnapshot(snapshot, state.memoryCheckpoint) : snapshot;
-    if (!memorySnapshot.eligible || !memorySnapshot.trajectory) {
-        advanceMemoryCheckpoint(state, snapshot.cursor);
-        ctx.logger("continual-evolve").info(`memory agent no-op (${snapshot.reason}) [${agent.id}]: no new eligible evidence after checkpoint`);
-        record({
-            sessionId,
-            reason: snapshot.reason,
-            turnsSinceLastReview,
-            outcome: "noop",
-            rationale: `memory no-op (${snapshot.reason}): no new eligible evidence after checkpoint`,
-            durationMs: Date.now() - startedAt,
-            memoryTurns: 0,
-            memorySearches: 0,
-            appliedEdits: 0,
-        });
-        return;
-    }
-    const declinedHit = matchDeclinedTrajectory(engine.baseDir, memorySnapshot.trajectory);
-    if (declinedHit !== undefined) {
-        advanceMemoryCheckpoint(state, memorySnapshot.cursor);
-        ctx.logger("continual-evolve").info(`memory agent pre-suppressed (${snapshot.reason}) [${agent.id}]: checkpoint overlaps declined ${declinedHit.entry.scope}:${declinedHit.entry.fingerprint} (coverage ${(declinedHit.coverage * 100).toFixed(0)}%, ${declinedHit.hits} tokens) — agent not invoked`);
-        record({
-            sessionId,
-            reason: snapshot.reason,
-            turnsSinceLastReview,
-            outcome: "noop",
-            rationale: `memory pre-suppressed (${snapshot.reason}): checkpoint overlaps declined ${declinedHit.entry.scope}:${declinedHit.entry.fingerprint} — agent not invoked`,
-            durationMs: Date.now() - startedAt,
-            memoryTurns: 0,
-            memorySearches: 0,
-            appliedEdits: 0,
-        });
-        return;
-    }
-    const projectKey = snapshot.projectKey ?? projectKeyOf(agent);
-    const baselines = {
-        local: engine.load("local", sessionId),
-        global: engine.load("global", undefined),
-        ...(projectKey ? { project: engine.load("project", projectKey) } : {}),
-    };
-    const manifest = buildMemoryManifest(loadGateHarnessView(engine, sessionId, projectKey ? { projectKey } : undefined));
-    const overrideRoute = parseReviewModel(config.reviewModel, agent.options.provider);
-    const provider = overrideRoute?.provider ?? agent.options.provider;
-    const model = overrideRoute?.model ?? agent.options.model;
-    if (!provider || !model)
-        throw new Error("evolve: no provider/model route for the memory extraction agent");
-    const tokenUsage = {
-        baseDir: engine.baseDir,
-        sessionId,
-        retain: engine.retention.tokenUsage,
-        onError: (cause) => ctx
-            .logger("continual-evolve")
-            .warn(`token-usage ledger failed for ${sessionId}: ${cause instanceof Error ? cause.message : String(cause)}`),
-    };
-    const run = await runMemoryAgent(ctx, {
-        provider,
-        model,
-        sessionId,
-        manifest,
-        trajectory: memorySnapshot.trajectory,
-        trajectoryEvents: memorySnapshot.events,
-        maxOutputTokens: config.budgetTokens,
-        ...(signal ? { signal } : {}),
-        tokenUsage,
-        language: resolveRecordLanguage({ configured: config.recordLanguage, ctx, trajectoryText: memorySnapshot.trajectory }),
-        ...((config.prefixCacheMode !== undefined || config.prefixMaxChars !== undefined
-            ? {
-                prefixCache: {
-                    ...(config.prefixCacheMode !== undefined ? { mode: config.prefixCacheMode } : {}),
-                    ...(config.prefixMaxChars !== undefined ? { maxChars: config.prefixMaxChars } : {}),
-                },
-            }
-            : {})),
-    });
-    if (run.proposal.edits.length === 0) {
-        advanceMemoryCheckpoint(state, memorySnapshot.cursor);
-        ctx.logger("continual-evolve").info(`memory agent no-op (${snapshot.reason}) [${sessionId}] after ${run.turns} turn(s): ${run.proposal.rationale}`);
-        record({
-            sessionId,
-            reason: snapshot.reason,
-            turnsSinceLastReview,
-            outcome: "noop",
-            rationale: `memory no-op (${snapshot.reason}) after ${run.turns} turn(s): ${run.proposal.rationale}`,
-            durationMs: Date.now() - startedAt,
-            memoryTurns: run.turns,
-            memorySearches: run.searches,
-            appliedEdits: 0,
-        });
-        return;
-    }
-    const source = { sessionId, ...(memorySnapshot.sourceSeqs.length > 0 ? { seqs: [...memorySnapshot.sourceSeqs] } : {}) };
-    const application = await applyMemoryExtractionProposal(ctx, engine, run.proposal, {
-        agent,
-        baselines,
-        ...(projectKey ? { projectKey } : {}),
-        requireApproval: config.requireGlobalApproval ?? true,
-        source,
-        decisionCursor: memorySnapshot.cursor,
-        scopeDecisions: state.memoryDecisions,
-        onScopeDecision: (key, decision) => rememberMemoryDecision(state, key, decision),
-        ...(config.recordLanguage !== undefined ? { recordLanguage: config.recordLanguage } : {}),
-        ...(signal ? { signal } : {}),
-    });
-    for (const result of application.results) {
-        emitEvolveComplete(engine.baseDir, buildEvolveCompleteEvent(result, `memory_agent:${snapshot.reason}`, sessionId), config.reviewsRetain ?? DEFAULT_REVIEWS_RETAIN);
-    }
-    state.memoryCheckpoint = memorySnapshot.cursor;
-    const applied = application.results.reduce((count, result) => count + result.appliedEdits.filter((edit) => edit.applied).length, 0);
-    const declined = application.declinedScopes.length > 0 ? `; declined scopes=${application.declinedScopes.join(",")}` : "";
-    const durationMs = Date.now() - startedAt;
-    for (const result of application.results) {
-        record({
-            sessionId,
-            reason: snapshot.reason,
-            turnsSinceLastReview,
-            outcome: "applied",
-            rationale: `memory applied (${snapshot.reason}) after ${run.turns} turn(s): ${run.proposal.rationale}${declined}`,
-            refinementId: result.id,
-            durationMs,
-            memoryTurns: run.turns,
-            memorySearches: run.searches,
-            appliedEdits: result.appliedEdits.filter((edit) => edit.applied).length,
-        });
-    }
-    if (application.declinedScopes.length > 0) {
-        record({
-            sessionId,
-            reason: snapshot.reason,
-            turnsSinceLastReview,
-            outcome: "declined",
-            rationale: `memory scopes declined (${snapshot.reason}): ${application.declinedScopes.join(",")}`,
-            durationMs,
-            memoryTurns: run.turns,
-            memorySearches: run.searches,
-            appliedEdits: 0,
-        });
-    }
-    ctx.logger("continual-evolve").info(`memory agent applied ${applied} edit(s) across ${application.results.length} scope batch(es) [${sessionId}] after ${run.turns} turn(s)${declined}: ${run.proposal.rationale}`);
-    // Visibility (P1 unified receipt): only applied outcomes wake the agent
-    // with a follow-up — and only on the goal-blocked moment, which runs
-    // mid-session; compaction and session-close stay audit-only
-    // (reviews.jsonl) so they never wake the agent mid-compaction or after
-    // disposal.
-    if (config.notifyOnAutoReview && snapshot.reason === "goal_blocked" && applied > 0) {
-        notifyMemoryExtraction(ctx, agent, {
-            outcome: "applied",
-            results: application.results,
-            ...(application.declinedScopes.length > 0 ? { declinedScopes: [...application.declinedScopes] } : {}),
-            turns: run.turns,
-            searches: run.searches,
-            durationMs,
-        });
-    }
-}
-//# sourceMappingURL=extraction-phase.js.map

package/lib/failures.d.ts

@@ -1,42 +0,0 @@
-export interface FailureRecord {
-    /** When the failure was recorded (ISO). Unknown for aggregated benchmark cells without timestamps. */
-    timestamp?: string;
-    /** Where the failure came from: "review-gate" | "benchmark:<bid>:<caseId>". */
-    source: string;
-    /** Failure class (see classifyFailure). */
-    kind: string;
-    /** The original failure text (notes or rationale). */
-    message: string;
-}
-export interface FailureSummary {
-    total: number;
-    /** Count per failure class, sorted descending (most frequent first). */
-    byKind: Record<string, number>;
-    /** Count per source (gate vs benchmark:bid). */
-    bySource: Record<string, number>;
-}
-/**
- * Classify a failure message by prefix rules. Deterministic and additive:
- * unknown text falls into "other" so the summary never drops a failure.
- */
-export declare function classifyFailure(message: string): string;
-/** Aggregate a record list into counts. Empty input yields an all-zero summary. */
-export declare function summarizeFailures(records: readonly FailureRecord[]): FailureSummary;
-/**
- * Read failed review-gate records from `<baseDir>/evolve/reviews.jsonl`
- * (outcome === "failed"). Tolerant of a missing/corrupt file.
- */
-export declare function readReviewFailures(baseDir: string): FailureRecord[];
-/**
- * Read failed cells from every benchmark scoreboard under
- * `<baseDir>/evolve/benchmarks/<bid>/`. Tolerant of missing/corrupt data.
- */
-export declare function readBenchmarkFailures(baseDir: string): FailureRecord[];
-/** Combine both sources into one summary. */
-export declare function collectFailureSummary(baseDir: string): {
-    summary: FailureSummary;
-    records: FailureRecord[];
-};
-/** Human-readable report for the command line. */
-export declare function formatFailureSummary(summary: FailureSummary): string;
-//# sourceMappingURL=failures.d.ts.map

package/lib/failures.js

@@ -1,171 +0,0 @@
-/**
- * Failure-signature aggregation (gap R/D1 — observation stage): turn the
- * free-text failure records the system already produces (review-gate failures
- * in reviews.jsonl, failed cells in benchmark scoreboards) into a structured
- * count by failure CLASS. This is deliberately NOT the full failure-signature
- * Refiner from gap D1 — no routing, no policy — it is the data layer that
- * lets a later patch decide whether a given failure class recurs often enough
- * to deserve one.
- *
- * Classes are extracted with pure prefix rules (see classifyFailure), so the
- * aggregation is deterministic and unit-testable: the same failure text
- * always lands in the same class.
- */
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-/**
- * Classify a failure message by prefix rules. Deterministic and additive:
- * unknown text falls into "other" so the summary never drops a failure.
- */
-export function classifyFailure(message) {
-    const text = (message ?? "").trim();
-    const lower = text.toLowerCase();
-    if (lower.includes("rubric decrypt failed"))
-        return "rubric-decrypt";
-    if (lower.includes("materials changed"))
-        return "material-drift";
-    if (lower.includes("executor failed") || lower.includes("executor stopped"))
-        return "executor";
-    if (lower.includes("reviewer failed") || lower.includes("reviewer stopped"))
-        return "reviewer";
-    if (lower.includes("fate assessment error"))
-        return "fate-assessor";
-    if (lower.includes("trajectory unavailable"))
-        return "trajectory";
-    if (lower.includes("output budget exhausted") || lower.includes("max-tokens"))
-        return "max-tokens";
-    if (lower.includes("llm call aborted") || lower.includes("aborted"))
-        return "aborted";
-    if (lower.includes("llm call failed"))
-        return "llm";
-    if (lower.includes("gate error"))
-        return "gate";
-    if (lower.includes("casecheck") || lower.includes("case check"))
-        return "casecheck";
-    return "other";
-}
-/** Aggregate a record list into counts. Empty input yields an all-zero summary. */
-export function summarizeFailures(records) {
-    const byKind = {};
-    const bySource = {};
-    for (const record of records) {
-        byKind[record.kind] = (byKind[record.kind] ?? 0) + 1;
-        bySource[record.source] = (bySource[record.source] ?? 0) + 1;
-    }
-    return {
-        total: records.length,
-        byKind: Object.fromEntries(Object.entries(byKind).sort((a, b) => b[1] - a[1])),
-        bySource: Object.fromEntries(Object.entries(bySource).sort((a, b) => b[1] - a[1])),
-    };
-}
-/**
- * Read failed review-gate records from `<baseDir>/evolve/reviews.jsonl`
- * (outcome === "failed"). Tolerant of a missing/corrupt file.
- */
-export function readReviewFailures(baseDir) {
-    const path = join(baseDir, "evolve", "reviews.jsonl");
-    if (!existsSync(path))
-        return [];
-    const records = [];
-    try {
-        for (const line of readFileSync(path, "utf8").split("\n")) {
-            if (line.trim().length === 0)
-                continue;
-            try {
-                const raw = JSON.parse(line);
-                if (raw.outcome !== "failed" || !raw.rationale)
-                    continue;
-                records.push({
-                    ...(raw.timestamp ? { timestamp: raw.timestamp } : {}),
-                    source: `review-gate${raw.reason ? `:${raw.reason}` : ""}`,
-                    kind: classifyFailure(raw.rationale),
-                    message: raw.rationale,
-                });
-            }
-            catch {
-                // skip malformed lines — the audit file must never break reporting
-            }
-        }
-    }
-    catch {
-        return [];
-    }
-    return records;
-}
-/**
- * Read failed cells from every benchmark scoreboard under
- * `<baseDir>/evolve/benchmarks/<bid>/`. Tolerant of missing/corrupt data.
- */
-export function readBenchmarkFailures(baseDir) {
-    const root = join(baseDir, "evolve", "benchmarks");
-    if (!existsSync(root))
-        return [];
-    const records = [];
-    let bids;
-    try {
-        bids = readdirSync(root);
-    }
-    catch {
-        return [];
-    }
-    for (const bid of bids) {
-        const boardPath = join(root, bid, "scoreboard.json");
-        if (!existsSync(boardPath))
-            continue;
-        let board;
-        try {
-            board = JSON.parse(readFileSync(boardPath, "utf8"));
-        }
-        catch {
-            continue;
-        }
-        const cellLists = [];
-        if (board.reference?.cells)
-            cellLists.push({ label: "reference", cells: board.reference.cells });
-        for (const entry of board.candidates ?? []) {
-            if (entry.cells)
-                cellLists.push({ label: entry.label ?? "candidate", cells: entry.cells });
-        }
-        for (const list of cellLists) {
-            for (const cell of list.cells) {
-                const c = cell;
-                if (c.status !== "failed" || !c.notes)
-                    continue;
-                records.push({
-                    source: `benchmark:${bid}:${c.caseId ?? "?"}`,
-                    kind: classifyFailure(c.notes),
-                    message: c.notes,
-                });
-            }
-        }
-    }
-    return records;
-}
-/** Combine both sources into one summary. */
-export function collectFailureSummary(baseDir) {
-    const records = [...readReviewFailures(baseDir), ...readBenchmarkFailures(baseDir)];
-    return { summary: summarizeFailures(records), records };
-}
-/** Human-readable report for the command line. */
-export function formatFailureSummary(summary) {
-    const lines = [`failure summary: ${summary.total} total`];
-    const kinds = Object.entries(summary.byKind);
-    if (kinds.length > 0) {
-        lines.push("by class:");
-        for (const [kind, count] of kinds) {
-            lines.push(`  ${kind}: ${count}`);
-        }
-    }
-    else {
-        lines.push("by class: (none)");
-    }
-    const sources = Object.entries(summary.bySource);
-    if (sources.length > 0) {
-        lines.push("by source:");
-        for (const [source, count] of sources) {
-            lines.push(`  ${source}: ${count}`);
-        }
-    }
-    return lines.join("\n");
-}
-//# sourceMappingURL=failures.js.map

package/lib/fate.d.ts

@@ -1,130 +0,0 @@
-/**
- * Gate local-fate dimension (#11 P2): the automatic review gate also decides
- * what happens to a session's local entries while the session is STILL
- * running — not only at wrap-up.
- *
- * Local entries default to orphans: a later session (not on the parentSession
- * chain) never sees them, and nothing promotes or archives them — the
- * exploration results effectively "die" with the session. This module gives
- * the gate its own fate cadence on top of the existing review:
- *
- * - `promote` → the entry moves into the global store. The global store is a
- *   governed resource: the user is consulted FIRST (the consultSkillEdits
- *   pattern — never written silently), with a cooldown after a decline.
- * - `archive` → hidden from injection (data stays restorable). Archives that
- *   would bury possibly-reusable content (not covered globally AND distilled
- *   from real user messages) ask the user first; covered/operational entries
- *   archive silently, exactly like the wrap-up command does.
- * - `keep` → nothing.
- *
- * At compaction the gate NEVER opens a dialog (the agent is mid-compaction):
- * only deterministic silent archives apply, everything governed is deferred
- * with an audit record pointing at `/evolve wrapup`.
- *
- * Division of labor is the same as wrap-up: the mechanical audit proposes
- * (listLocalCandidates + coverage guards), the LLM classifies
- * (assessLocalEntries), the user approves, the code applies deterministically
- * (wholePromoteProposals / splitPromoteProposals — the SAME edits the wrap-up
- * command applies). Every decision lands in reviews.jsonl via the gate's
- * record callback.
- */
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import type { HarnessState, RefinementResult } from "./types.js";
-import type { EvolutionEngine } from "./service.js";
-import type { AutoRefineReason } from "./review.js";
-import type { AutoReviewConfig, GateState, ReviewRecord } from "./auto.js";
-import { type PromotionPolicy } from "./promotion.js";
-import { type RecordLanguage } from "./record-language.js";
-import { type WrapupCandidate, type WrapupItem } from "./wrapup.js";
-/** Turns a declined local-fate proposal stays silent before being offered again. */
-export declare const FATE_CONSULT_COOLDOWN_TURNS = 10;
-/** What the gate decided to do with the session's local entries. */
-export interface FatePlan {
-    candidates: readonly WrapupCandidate[];
-    /** Whole promotions that passed the deterministic global-coverage guard. */
-    promotable: WrapupItem[];
-    /** Split promotions (archive + cleaned promote payload) that passed the guard. */
-    splits: {
-        item: WrapupItem;
-        candidate: WrapupCandidate;
-    }[];
-    /** Archives that may proceed silently (covered globally / no real distillation source). */
-    silentArchives: WrapupItem[];
-    /** Archives that must ask the user first (uncovered + real source). */
-    reviewArchives: WrapupItem[];
-    /** Promotes blocked by the deterministic guard, with why. */
-    skipped: {
-        key: string;
-        reason: string;
-    }[];
-    /** Split promotions blocked by the deterministic guard, with why. */
-    splitSkipped: {
-        key: string;
-        reason: string;
-    }[];
-}
-/**
- * Partition an assessed wrap-up classification into concrete fate actions,
- * re-running the deterministic guards against the LIVE global store (state
- * may have changed while the LLM call was in flight). Pure and unit-tested;
- * mirrors the partition step of the wrap-up command.
- */
-export declare function planLocalFates(items: readonly WrapupItem[], candidates: readonly WrapupCandidate[], globalState: HarnessState, policy?: PromotionPolicy): FatePlan;
-/**
- * The cooldown key of a candidate set: the sorted `kind:id` list. The set is
- * the unit of consultation — a declined proposal is not offered again within
- * the cooldown window, and a changed set (new entries appeared) starts a
- * fresh consultation.
- */
-export declare function fateSetKey(candidates: readonly WrapupCandidate[]): string;
-/**
- * Whether the local-fate dimension is due for this gate run. Turn-interval
- * gates respect the fate cadence (an independent counter — goal-driven
- * sessions run the review EVERY round, the fate assessment must not);
- * compaction is unconditional: experiences about to be summarized away get
- * their fate check regardless. Goal-blocked assessments are unconditional
- * here too — the gate's own streak counter (auto.ts runGoalBlockedFate)
- * already gates their frequency, so the cadence must not re-block them.
- */
-export declare function fateCadenceDue(state: GateState, reason: AutoRefineReason, intervalTurns: number): boolean;
-export interface FateConsultResult {
-    approved: boolean;
-    asked: boolean;
-    reason: "nothing-to-ask" | "consented" | "declined" | "cooldown" | "unavailable" | "error";
-}
-/**
- * Ask the user whether to execute the gate's local-fate proposal. ONE dialog
- * covers every governed action (promotes, split promotions, review-required
- * archives) — the gate never spams questions. Conservative on every edge:
- * no question service → not approved; the question call fails → not approved;
- * the same candidate set was declined within the cooldown → not asked again.
- * A decline records the cooldown (the consultSkillEdits pattern).
- */
-export declare function consultLocalFates(ctx: Context, agent: Agent, plan: FatePlan, gate: GateState, language?: RecordLanguage): Promise<FateConsultResult>;
-export type FateApplyMode = "full" | "silent-only";
-export interface FateApplyResult {
-    /** Human-readable lines of what was applied (for the notice and the audit record). */
-    applied: string[];
-    /** Every refinement result produced, for rollback discovery. */
-    results: RefinementResult[];
-}
-/**
- * Deterministically apply the fate plan. `"full"` applies everything
- * (promotes, splits, silent + review archives); `"silent-only"` applies only
- * the deterministic silent archives (the compaction path — nothing governed).
- * Promotes go through the SAME proposals as the wrap-up command
- * (wholePromoteProposals / splitPromoteProposals), so both paths write
- * identical global entries and local retirement stamps.
- */
-export declare function applyLocalFates(engine: EvolutionEngine, sessionId: string, plan: FatePlan, localState: HarnessState, mode: FateApplyMode): FateApplyResult;
-/**
- * The gate's local-fate phase. Runs after the review phase on every gate
- * trigger (turn_snapshot / compact), subject to cadence and cooldown. All
- * failures are contained and recorded — a broken fate dimension never
- * disturbs the agent loop.
- */
-export declare function runLocalFatePhase(ctx: Context, engine: EvolutionEngine, agent: Agent, config: AutoReviewConfig, state: GateState, reason: AutoRefineReason, record: (entry: Omit<ReviewRecord, "timestamp">) => void): Promise<void>;
-/** The user-visible notice after the gate applied local-fate actions. */
-export declare function buildFateNotice(applied: readonly string[]): string;
-//# sourceMappingURL=fate.d.ts.map