@sema-agent/core 5.54.0 → 5.55.0

package/dist/core/memory-engine/engine.js

@@ -6,9 +6,10 @@ import { MAX_MEMORY_BYTES, composeMemoryBlock, firstSentence } from "../memory.j
 import { inlineUntrusted } from "../untrusted-text.js";
 import { mintSystemReminder } from "../reminder-mint.js";
 import { formatMemoryAge } from "../memory-recall.js";
-import { committedOriginOf, computeEntryRev, hasOriginFormExtra, isValidEntryId, originEquals, parseEntryFile, serializeEntryFile, stripModelWrittenOrigin } from "./frontmatter.js";
+import { committedDistilledOf, committedOriginOf, computeEntryRev, distilledEquals, hasDistilledFormExtra, hasOriginFormExtra, isValidEntryId, originEquals, parseEntryFile, serializeEntryFile, stripModelWrittenDistilled, stripModelWrittenOrigin } from "./frontmatter.js";
 import { MEMORY_PROVENANCE_RECALL_SENTENCE, memoryExposureIndexRow, parseMemoryExposureIndexRow } from "./provenance-wording.js";
 import { isInstructionEntry } from "./header-hints.js";
+import { ConsolidationRefusedError, CONSOLIDATION_FORCE_THROTTLE_FLOOR_MS, CONSOLIDATION_SEAT_FREEZE_GRACE_MS, consolidationTypeEligible, deriveProductSlug, deriveSupersededSet, isValidConsolidationPlanId, listConsolidationPlanIds, productAddPatch, quarantineCorruptPlan, readConsolidationGateFile, readConsolidationPlan, readIntentCredentials, recordActiveSetBaseline, recordConsolidationSession, recordIntentCredentials, screenConsolidationOptions, supersessionFuseCeiling, updateConsolidationGate, writeConsolidationPlan, } from "./consolidation.js";
 import { classifySessionSettlements, clearHoldResolution, closeSessionAccount, disposeHold, effectiveSettlements, expireOverdueSettlements, foreignDanglingSessionAccounts, markHoldReleased, openInstructionHold, openSessionAccount, readHoldCustody, readHolds, reconcileHolds, replayExternalSettlementEffects, resolveHoldRecord, resolveSessionAccountRecord, resolveSettlementRecord, sessionSettlements, sessionUnattributedSet, } from "./delegation-settlement.js";
 import { noReplaceRestore } from "./delegation-settlement.js";
 import { markOriginClearanceTombstoned, openOriginClearance, readOriginClearances, settleOriginClearance } from "./origin-clearance.js";
@@ -65,7 +66,7 @@ export const MEMORY_ANNOUNCEMENT_READONLY_PLANE_CODA = "The notices immediately
 export const MEMORY_ANNOUNCEMENT_READONLY_CODA = "The memory store itself is not writable this session, so any guidance above to record, update, or tombstone a memory entry cannot be applied here — surface it to the user instead of claiming it done.";
 export const MEMORY_READONLY_NOTICE = `# Memory
 
-You have READ-ONLY access to persistent memory in this session: stored notes are available below, but this session has no memory write channel — the engine will not accept writes into the memory store. If the user asks you to remember something for later, say plainly that you cannot save it in this session — never claim to have noted or remembered it.`;
+You have READ-ONLY access to persistent memory in this session: stored notes are available below, but this session has no memory write channel — the engine will not accept writes into the memory store. If the user asks you to remember something, explain that memory is read-only in this session.`;
 export const MEMORY_INDEX_MAX_LINES = 200;
 export const MEMORY_INDEX_MAX_BYTES = 25 * 1024;
 export const STUB_ARCHIVED_LINE = "[body archived — request hydration by listing the slug in memory/.hydrate]";
@@ -170,6 +171,37 @@ export function memoryHoldNotices(report, sessionId) {
     }
     return notices;
 }
+export function memoryConsolidationRecommendedNotice(report, sessionId) {
+    const rec = report.consolidationRecommended;
+    if (rec === undefined)
+        return undefined;
+    return {
+        code: "memory.consolidation_recommended",
+        message: `Memory consolidation is recommended for scope ${inlineUntrusted(rec.scope, 80)}: ${rec.sessionsSince} distinct session(s) harvested since the last run and the time gate is open. The host decides — nothing runs automatically.`,
+        detail: { scope: inlineUntrusted(rec.scope, 80), sessionsSince: rec.sessionsSince, ...(sessionId !== undefined ? { sessionId } : {}) },
+    };
+}
+export function memoryConsolidationCommittedNotice(input) {
+    return {
+        code: "memory.consolidation_committed",
+        message: `Memory consolidation plan ${input.planId} completed: ${input.products} product(s) committed, ${input.superseded} entr${input.superseded === 1 ? "y" : "ies"} superseded (retained as evidence), ${input.intents} intent(s) settled.`,
+        detail: { planId: input.planId, scope: inlineUntrusted(input.scope, 80), products: input.products, superseded: input.superseded, intents: input.intents },
+    };
+}
+export function memoryConsolidationConflictNotice(input) {
+    return {
+        code: "memory.consolidation_conflict",
+        message: `Memory consolidation plan ${input.planId} parked CONFLICT — at least one target did not reach its planned state (a concurrent write, a patch the store declined, or a target the plan could no longer act on; the plan's audit rows carry the per-target reason). Those targets were NOT overwritten, but patches this plan had already applied stand and are not rolled back by discard (the receipt's product/directed applied-vs-conflict counts say how many). The affected intents stay pending, and resolveConsolidationPlan(planId, "retry" | "discard") is the host valve.`,
+        detail: { planId: input.planId, scope: inlineUntrusted(input.scope, 80) },
+    };
+}
+export function memoryConsolidationRefusedNotice(input) {
+    return {
+        code: "memory.consolidation_refused",
+        message: `A memory consolidation verb refused (${input.code})${input.reason !== undefined ? `: ${inlineUntrusted(input.reason, 200)}` : "."}`,
+        detail: { refusalCode: input.code, ...(input.scope !== undefined ? { scope: inlineUntrusted(input.scope, 80) } : {}) },
+    };
+}
 export class MemoryEngine {
     backend;
     memoryDir;
@@ -218,7 +250,11 @@ export class MemoryEngine {
         }
         this.holdSettleTimeoutMs = opts.holdSettleTimeoutMs ?? DEFAULT_HOLD_SETTLE_TIMEOUT_MS;
         this.onIncident = opts.onIncident;
+        if (opts.consolidation !== undefined) {
+            this.consolidation = screenConsolidationOptions(opts.consolidation, this.provenance);
+        }
     }
+    consolidation;
     discloseSessionAccountIncident(what, cause) {
         const sink = this.onIncident;
         if (sink === undefined)
@@ -1075,6 +1111,37 @@ export class MemoryEngine {
         const indexText = this.rebuildIndex(handle, headers, { write: indexWrite, ignoreOnDisk: indexGate !== undefined || restricted }, materializeHealWarnings);
         handle.indexBaselineLines = countIndexLines(indexText);
         handle.indexText = indexText;
+        if (this.consolidation !== undefined) {
+            try {
+                const fuseExclusions = this.readChallengeExclusions();
+                const fuseSuperseded = deriveSupersededSet(headers, { excluded: (id) => fuseExclusions.has(id) });
+                for (const scope of new Set(headers.map((h) => h.scope))) {
+                    const size = headers.filter((h) => h.scope === scope && !fuseSuperseded.has(h.id) && !fuseExclusions.has(h.id)).length;
+                    const rec = recordActiveSetBaseline(this.controlDir, scope, size, this.consolidation.supersedeRatioCap, this.now);
+                    if (rec.collapsed !== undefined) {
+                        const detail = `memory active set for scope ${inlineUntrusted(scope, 80)} collapsed ${rec.collapsed.from} → ${rec.collapsed.to} in one window (over the ${this.consolidation.supersedeRatioCap} ratio cap) — superseded entries stay readable as evidence; audit the recent consolidation plans and adoptions`;
+                        const sink = this.onIncident;
+                        if (sink !== undefined) {
+                            try {
+                                const e = new Error(detail);
+                                e.code = "memory.active_set_collapse";
+                                sink(e);
+                            }
+                            catch {
+                            }
+                        }
+                        try {
+                            enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at: this.now(), items: [detail] });
+                        }
+                        catch (err) {
+                            this.discloseAnnounceFailure("active-set collapse enqueue", err);
+                        }
+                    }
+                }
+            }
+            catch {
+            }
+        }
         if (indexWrite && handle.indexOnDiskUntrusted !== true) {
             const dropNotes = materializeHealWarnings.filter((w) => w.includes("opaque external-origin handle"));
             if (dropNotes.length > 0) {
@@ -1668,6 +1735,13 @@ export class MemoryEngine {
                     report.warnings.push(`${rel}: origin-form frontmatter written on the model-visible plane was not adopted — the external-origin marker is engine-authored (the engine's own record of this session decides it)`);
                 }
             }
+            if (stripModelWrittenDistilled(fm)) {
+                const committedDistilledEcho = committedFmHere !== undefined ? committedDistilledOf(committedFmHere) : undefined;
+                const benignDistilledEcho = committedDistilledEcho !== undefined && distilledEquals(parsed.frontmatter.distilled, committedDistilledEcho) && !hasDistilledFormExtra(parsed.frontmatter);
+                if (!benignDistilledEcho) {
+                    report.warnings.push(`${rel}: distilled-form frontmatter written on the model-visible plane was not adopted — the consolidation lineage block is engine-authored (minted only by a consolidation plan freeze)`);
+                }
+            }
             const instructionForm = carry && (isInstructionEntry(fm) || (committedFmHere !== undefined && isInstructionEntry(committedFmHere)));
             if (instructionForm && unattributedSet.has(rel)) {
                 await containPollutedRecord(f, "this file pre-existed the session under an unresolved foreign session account (crash residue) and is instruction-form — its writer cannot be attributed, so it is withheld for host review");
@@ -1733,6 +1807,9 @@ export class MemoryEngine {
                 else if (carry && pollutedReason !== undefined) {
                     fm.origin = mintOrigin();
                 }
+                const committedDistilled = committedFmHere !== undefined ? committedDistilledOf(committedFmHere) : undefined;
+                if (committedDistilled !== undefined)
+                    fm.distilled = committedDistilled;
             }
             if (fm.name === undefined)
                 fm.name = f.slug.split("/").pop();
@@ -2160,6 +2237,36 @@ export class MemoryEngine {
                 report.warnings.push(`memory session account close FAILED and its outcome is UNKNOWN (a failure after the ledger's journal commit still rolls forward, so the account may read closed at the next strict read; a failure before it leaves the ledger's PRIOR state — open, already closed, valve-closed or absent — unchanged, and an open one keeps future crash residue attributed, the over-holding safe side)${deferredSeats.length > 0 ? `; ${deferredSeats.length} file(s) also stay DEFERRED on the plane under standing projection-debt rows: ${seatList}` : ""}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
+        if (this.consolidation !== undefined && handle.writeScope !== null && opts?.sessionId !== undefined && report.ok) {
+            try {
+                const rec = recordConsolidationSession(this.controlDir, handle.writeScope, opts.sessionId, this.consolidation, this.now);
+                if (rec.recommended) {
+                    report.consolidationRecommended = { scope: handle.writeScope, sessionsSince: rec.sessionsSince };
+                    try {
+                        enqueueMemoryAnnouncement(this.controlDir, {
+                            kind: "gate",
+                            at: this.now(),
+                            items: [`memory consolidation recommended for scope ${inlineUntrusted(handle.writeScope, 80)}: ${rec.sessionsSince} distinct session(s) since the last run — the host decides (nothing runs automatically)`],
+                        });
+                    }
+                    catch (err) {
+                        this.discloseAnnounceFailure("consolidation recommendation enqueue", err);
+                    }
+                }
+            }
+            catch (err) {
+                const sink = this.onIncident;
+                if (sink !== undefined) {
+                    try {
+                        const e = new Error(`memory consolidation gate counting failed (advisory — the verbs refuse loudly over a broken store): ${err instanceof Error ? err.message : String(err)}`);
+                        e.code = "memory.consolidation_gate_failed";
+                        sink(e);
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
         return report;
     }
     async settleDueHolds(handle, report) {
@@ -2236,8 +2343,14 @@ export class MemoryEngine {
         if (stripModelWrittenOrigin(fm)) {
             report.warnings.push(`${row.relPath}: origin-form frontmatter in the held bytes was not adopted — the external-origin marker is engine-authored`);
         }
+        if (stripModelWrittenDistilled(fm)) {
+            report.warnings.push(`${row.relPath}: distilled-form frontmatter in the held bytes was not adopted — the consolidation lineage block is engine-authored`);
+        }
         const committedFm = row.entryId !== undefined ? await this.committedFrontmatterFor(row.entryId) : undefined;
         const committedOrigin = committedFm !== undefined ? committedOriginOf(committedFm) : undefined;
+        const committedDistilledHold = committedFm !== undefined ? committedDistilledOf(committedFm) : undefined;
+        if (fm.deleted !== true && committedDistilledHold !== undefined)
+            fm.distilled = committedDistilledHold;
         if (fm.deleted !== true) {
             if (committedOrigin !== undefined)
                 fm.origin = committedOrigin;
@@ -2347,6 +2460,988 @@ export class MemoryEngine {
     readDanglingSessionAccounts(selfSessionId) {
         return foreignDanglingSessionAccounts(this.controlDir, selfSessionId);
     }
+    requireConsolidation() {
+        if (this.consolidation === undefined) {
+            throw new ConsolidationRefusedError("memory.consolidation_disabled", "memory consolidation is not enabled on this engine (MemoryEngineOptions.consolidation is absent — the v3 default is OFF; the host enables it explicitly).");
+        }
+        return this.consolidation;
+    }
+    readConsolidationGateOrRefuse() {
+        try {
+            return readConsolidationGateFile(this.controlDir);
+        }
+        catch (err) {
+            throw new ConsolidationRefusedError("memory.consolidation_gate_corrupt", `memory consolidation gate store cannot be trusted (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async releaseConsolidationLease(scope) {
+        try {
+            await this.consolidation?.lease?.release?.(scope);
+        }
+        catch {
+        }
+    }
+    async consolidationLeaseCurrent(scope, frozenToken) {
+        const lease = this.consolidation?.lease;
+        if (lease === undefined)
+            return true;
+        const held = (await (lease.renew?.(scope) ?? lease.acquire(scope))) ?? undefined;
+        if (held === undefined)
+            return false;
+        return frozenToken === undefined || held.token === frozenToken;
+    }
+    consolidationEligibility(headers) {
+        let exclusions;
+        try {
+            exclusions = this.readChallengeExclusions();
+        }
+        catch (err) {
+            throw new ConsolidationRefusedError("memory.consolidation_governance_unreadable", `memory consolidation refused: the challenge/lineage ledger cannot be trusted (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const superseded = deriveSupersededSet(headers, { excluded: (id) => exclusions.has(id) });
+        const pendingSessions = new Set();
+        try {
+            for (const s of effectiveSettlements(this.controlDir))
+                if (s.effective === "pending")
+                    pendingSessions.add(s.row.sessionId);
+        }
+        catch (err) {
+            throw new ConsolidationRefusedError("memory.consolidation_governance_unreadable", `memory consolidation refused: the delegation-settlement account cannot be trusted (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        let lineageByEntry = {};
+        try {
+            lineageByEntry = readLineageRecord(this.controlDir).committed;
+        }
+        catch (err) {
+            throw new ConsolidationRefusedError("memory.consolidation_governance_unreadable", `memory consolidation refused: the lineage ledger cannot be trusted (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const eligible = new Map();
+        for (const h of headers) {
+            if (exclusions.has(h.id))
+                continue;
+            if (superseded.has(h.id))
+                continue;
+            if (h.distilled !== undefined)
+                continue;
+            if (!consolidationTypeEligible(h.type))
+                continue;
+            if (h.exposure === undefined && pendingSessions.size > 0) {
+                const contributors = Object.keys(lineageByEntry[h.id] ?? {});
+                if (contributors.some((s) => pendingSessions.has(s)))
+                    continue;
+            }
+            eligible.set(h.id, h);
+        }
+        return { exclusions, superseded, eligible };
+    }
+    async snapshotConsolidationCandidates(scope, opts = {}) {
+        const screened = this.requireConsolidation();
+        const gate = this.readConsolidationGateOrRefuse();
+        const row = gate.scopes[scope];
+        const at = this.now();
+        if (row?.openPlanId !== undefined) {
+            throw new ConsolidationRefusedError("memory.consolidation_busy", `memory consolidation refused: plan ${row.openPlanId} holds the ${JSON.stringify(scope)} seat (reconcile or resolve it first — the mutex yields to no force).`);
+        }
+        if (row?.lastRunAt !== undefined) {
+            const throttleWindow = Math.min(screened.minRunIntervalMs, CONSOLIDATION_FORCE_THROTTLE_FLOOR_MS);
+            if (at - row.lastRunAt < throttleWindow) {
+                throw new ConsolidationRefusedError("memory.consolidation_gated", `memory consolidation refused (throttle): the last ${JSON.stringify(scope)} run settled ${at - row.lastRunAt}ms ago — the same-scope cost floor (${throttleWindow}ms) yields to no force.`);
+            }
+            if (opts.force === undefined && at - row.lastRunAt < screened.minRunIntervalMs) {
+                throw new ConsolidationRefusedError("memory.consolidation_gated", `memory consolidation refused (time gate): the last ${JSON.stringify(scope)} run settled ${at - row.lastRunAt}ms ago (< minRunIntervalMs ${screened.minRunIntervalMs}ms). Pass force with a requestId for an on-demand run.`);
+            }
+        }
+        if (opts.force === undefined && (row?.sessions.count ?? 0) < screened.minSessionsBetweenRuns) {
+            throw new ConsolidationRefusedError("memory.consolidation_gated", `memory consolidation refused (session gate): ${row?.sessions.count ?? 0} distinct session(s) since the last run (< minSessionsBetweenRuns ${screened.minSessionsBetweenRuns}). Pass force with a requestId for an on-demand run.`);
+        }
+        const face = this.committedAuditFace();
+        const headers = await face.listHeaders([scope]);
+        const { eligible } = this.consolidationEligibility(headers);
+        const fingerprint = opts.full === true ? undefined : row?.fingerprint;
+        const candidateIds = [];
+        for (const [id, h] of eligible) {
+            const fp = fingerprint?.[id];
+            if (fp === undefined || fp.rev !== h.rev)
+                candidateIds.push(id);
+        }
+        const entries = await face.getByIds(candidateIds);
+        const candidates = entries
+            .filter((e) => e.frontmatter.deleted !== true)
+            .map((e) => ({ entry: e, marked: committedOriginOf(e.frontmatter) !== undefined }));
+        const candidateRevs = {};
+        for (const c of candidates)
+            candidateRevs[c.entry.id] = c.entry.rev;
+        const eligibleRevs = {};
+        for (const [id, h] of eligible)
+            eligibleRevs[id] = h.rev;
+        const marked = candidates.some((c) => c.marked);
+        const epoch = row?.epoch ?? 0;
+        const cycleToken = createHash("sha256").update(JSON.stringify([scope, epoch, at, Object.entries(candidateRevs).sort()]), "utf8").digest("hex").slice(0, 32);
+        updateConsolidationGate(this.controlDir, (file) => {
+            const fresh = file.scopes[scope] ?? { sessions: { count: 0, ring: [] }, epoch: 0 };
+            if (fresh.openPlanId !== undefined) {
+                throw new ConsolidationRefusedError("memory.consolidation_busy", `memory consolidation refused: plan ${fresh.openPlanId} claimed the ${JSON.stringify(scope)} seat during the snapshot read.`);
+            }
+            if (fresh.epoch !== epoch) {
+                throw new ConsolidationRefusedError("memory.consolidation_stale_snapshot", `memory consolidation refused: the ${JSON.stringify(scope)} watermark advanced during the snapshot read — retake the snapshot.`);
+            }
+            fresh.snapshot = { token: cycleToken, at, epoch, candidates: candidateRevs, eligible: eligibleRevs, marked };
+            file.scopes[scope] = fresh;
+            return { next: file, result: undefined };
+        });
+        if (opts.force !== undefined) {
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at, items: [`memory consolidation snapshot FORCED past the time/session gates for scope ${inlineUntrusted(scope, 80)} (requestId ${inlineUntrusted(opts.force.requestId, 80)})`] });
+            }
+            catch (err) {
+                this.discloseAnnounceFailure("consolidation force audit enqueue", err);
+            }
+        }
+        return { cycleToken, watermark: { epoch, at }, candidates };
+    }
+    async commitConsolidationPlan(cycleToken, proposal, opts) {
+        const screened = this.requireConsolidation();
+        const scope = proposal.scope;
+        if (typeof scope !== "string" || scope.length === 0)
+            throw new ConsolidationRefusedError("memory.consolidation_refused", "memory consolidation plan refused: proposal.scope must be a non-empty string.");
+        const reasons = [];
+        if (proposal.products.length > screened.maxProductsPerRun)
+            reasons.push(`products ${proposal.products.length} > maxProductsPerRun ${screened.maxProductsPerRun}`);
+        const intents = proposal.intents ?? [];
+        if (intents.length > screened.maxDirectedPatchesPerPlan)
+            reasons.push(`directed intents ${intents.length} > maxDirectedPatchesPerPlan ${screened.maxDirectedPatchesPerPlan}`);
+        const intentIds = new Set();
+        for (const intent of intents) {
+            if (typeof intent.requestId !== "string" || intent.requestId.length === 0)
+                reasons.push("an intent carries no requestId");
+            else if (intentIds.has(intent.requestId))
+                reasons.push(`duplicate intent requestId ${JSON.stringify(intent.requestId)}`);
+            else
+                intentIds.add(intent.requestId);
+        }
+        let credentials = {};
+        try {
+            credentials = readIntentCredentials(this.controlDir);
+        }
+        catch (err) {
+            throw new ConsolidationRefusedError("memory.consolidation_gate_corrupt", `memory consolidation refused: the intent-credential account cannot be trusted (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        for (const intent of intents) {
+            const existing = credentials[intent.requestId];
+            if (existing !== undefined)
+                reasons.push(`intent ${JSON.stringify(intent.requestId)} already carries a credential (${existing.state}) — a consumed intent is never re-frozen`);
+        }
+        for (let i = 0; i < proposal.products.length; i++) {
+            const p = proposal.products[i];
+            if (typeof p.body !== "string" || p.body.trim() === "")
+                reasons.push(`product #${i}: empty body`);
+            if (!Array.isArray(p.inputs) || p.inputs.length === 0)
+                reasons.push(`product #${i}: zero declared inputs (a distillation always has material)`);
+            else if (p.inputs.length > screened.maxInputsPerProduct)
+                reasons.push(`product #${i}: ${p.inputs.length} inputs > maxInputsPerProduct ${screened.maxInputsPerProduct}`);
+        }
+        if (reasons.length > 0)
+            throw new ConsolidationRefusedError("memory.consolidation_refused", "memory consolidation plan refused (structural)", reasons);
+        const planId = uuidv7();
+        const snapshot = updateConsolidationGate(this.controlDir, (file) => {
+            const row = file.scopes[scope] ?? { sessions: { count: 0, ring: [] }, epoch: 0 };
+            if (row.openPlanId !== undefined) {
+                throw new ConsolidationRefusedError("memory.consolidation_busy", `memory consolidation refused: plan ${row.openPlanId} already holds the ${JSON.stringify(scope)} seat (one plan at a time; resolve or reconcile it first).`);
+            }
+            if (row.snapshot === undefined || row.snapshot.token !== cycleToken || row.snapshot.epoch !== row.epoch) {
+                throw new ConsolidationRefusedError("memory.consolidation_stale_snapshot", `memory consolidation refused: the cycle token does not match the ${JSON.stringify(scope)} scope's current snapshot (another cycle completed, or a newer snapshot replaced it) — retake the snapshot.`);
+            }
+            row.openPlanId = planId;
+            row.seatClaimedAt = this.now();
+            file.scopes[scope] = row;
+            return { next: file, result: row.snapshot };
+        });
+        let frozenLeaseToken;
+        if (screened.lease !== undefined) {
+            const held = (await screened.lease.acquire(scope)) ?? undefined;
+            if (held === undefined) {
+                updateConsolidationGate(this.controlDir, (file) => {
+                    const row = file.scopes[scope];
+                    if (row?.openPlanId === planId) {
+                        delete row.openPlanId;
+                        file.scopes[scope] = row;
+                        return { next: file, result: undefined };
+                    }
+                    return { result: undefined };
+                });
+                throw new ConsolidationRefusedError("memory.consolidation_lease_unavailable", `memory consolidation refused: the global lease for scope ${JSON.stringify(scope)} could not be acquired.`);
+            }
+            frozenLeaseToken = held.token;
+        }
+        let frozen = false;
+        try {
+            const { plan, refusedProducts } = await this.freezeConsolidationPlan({ planId, scope, requestId: opts.requestId, cycleToken, snapshot, proposal, screened });
+            frozen = true;
+            const receipt = await this.applyConsolidationPlan(plan, frozenLeaseToken);
+            receipt.products.refused = refusedProducts;
+            await this.releaseConsolidationLease(scope);
+            return receipt;
+        }
+        catch (err) {
+            await this.releaseConsolidationLease(scope);
+            if (!frozen && err instanceof ConsolidationRefusedError) {
+                updateConsolidationGate(this.controlDir, (file) => {
+                    const row = file.scopes[scope];
+                    if (row?.openPlanId === planId) {
+                        delete row.openPlanId;
+                        file.scopes[scope] = row;
+                        return { next: file, result: undefined };
+                    }
+                    return { result: undefined };
+                });
+                if (err.code === "memory.consolidation_refused") {
+                    try {
+                        enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at: this.now(), items: [`memory consolidation plan for scope ${inlineUntrusted(scope, 80)} REFUSED: ${inlineUntrusted(err.reasons[0] ?? err.message, 200)}`] });
+                    }
+                    catch (annErr) {
+                        this.discloseAnnounceFailure("consolidation refusal enqueue", annErr);
+                    }
+                }
+            }
+            throw err;
+        }
+    }
+    async freezeConsolidationPlan(input) {
+        const { planId, scope, snapshot, proposal, screened } = input;
+        const at = this.now();
+        const face = this.committedAuditFace();
+        const headers = await face.listHeaders([scope]);
+        const { exclusions, superseded } = this.consolidationEligibility(headers);
+        const headerById = new Map(headers.map((h) => [h.id, h]));
+        const wholeReasons = [];
+        for (let i = 0; i < proposal.products.length; i++) {
+            for (const input2 of proposal.products[i].inputs) {
+                if (snapshot.candidates[input2.id] === undefined)
+                    wholeReasons.push(`product #${i}: declared input ${JSON.stringify(input2.id)} is not in the snapshot candidate set`);
+            }
+        }
+        const activeSetSize = headers.filter((h) => !superseded.has(h.id) && !exclusions.has(h.id)).length;
+        const edgeTargets = new Set();
+        for (const p of proposal.products)
+            for (const i2 of p.inputs)
+                if (i2.supersede === true)
+                    edgeTargets.add(i2.id);
+        const ceiling = supersessionFuseCeiling(activeSetSize, screened);
+        if (edgeTargets.size > ceiling) {
+            wholeReasons.push(`supersession fuse: ${edgeTargets.size} distinct targets > ceiling ${ceiling} (active set ${activeSetSize}, ratio ${screened.supersedeRatioCap}, floor ${screened.supersedeAbsoluteFloor}, N-1 unconditional)`);
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at, items: [`memory consolidation plan for scope ${inlineUntrusted(scope, 80)} REFUSED by the supersession fuse (${edgeTargets.size} targets over the ${ceiling} ceiling)`] });
+            }
+            catch (err) {
+                this.discloseAnnounceFailure("consolidation fuse enqueue", err);
+            }
+        }
+        let visibleMarked = snapshot.marked;
+        if (!visibleMarked) {
+            const inputIds = [...new Set(proposal.products.flatMap((p) => p.inputs.map((i2) => i2.id)))];
+            const committedInputs = await face.getByIds(inputIds);
+            visibleMarked = committedInputs.some((e) => committedOriginOf(e.frontmatter) !== undefined);
+        }
+        const foldedOrigin = visibleMarked ? { taint: "external", cause: "derived", at } : undefined;
+        for (let i = 0; i < proposal.products.length; i++) {
+            const p = proposal.products[i];
+            if (visibleMarked && isInstructionEntry({ ...(p.type !== undefined ? { type: p.type } : {}) })) {
+                wholeReasons.push(`product #${i}: instruction-form product (type ${JSON.stringify(p.type)}) refused — the run's visible set contains marked content (the laundering hard gate, G7/G26)`);
+            }
+        }
+        const assembled = [];
+        const refusedProducts = [];
+        for (let i = 0; i < proposal.products.length; i++) {
+            const p = proposal.products[i];
+            const drift = [];
+            for (const input2 of p.inputs) {
+                if (snapshot.candidates[input2.id] === undefined)
+                    continue;
+                const h = headerById.get(input2.id);
+                if (h === undefined)
+                    drift.push(`input ${input2.id} is no longer committed`);
+                else if (h.rev !== snapshot.candidates[input2.id])
+                    drift.push(`input ${input2.id} moved rev since the snapshot`);
+                else if (exclusions.has(input2.id))
+                    drift.push(`input ${input2.id} is challenged/latched`);
+                else if (input2.supersede === true && !consolidationTypeEligible(h.type))
+                    drift.push(`supersession target ${input2.id} is ${h.type} (episodic/procedural targets are refused)`);
+            }
+            if (drift.length > 0) {
+                refusedProducts.push({ index: i, reason: drift.join("; ") });
+                continue;
+            }
+            const id = uuidv7();
+            const slug = deriveProductSlug(p.name, `consolidated-${id.slice(0, 8)}`);
+            const entry = {
+                id,
+                slug,
+                scope,
+                frontmatter: {
+                    name: p.name ?? slug,
+                    ...(p.description !== undefined ? { description: p.description } : {}),
+                    ...(p.type !== undefined ? { type: p.type } : {}),
+                    ...(foldedOrigin !== undefined ? { origin: { ...foldedOrigin } } : {}),
+                    distilled: {
+                        planId,
+                        at,
+                        carrierRev: "",
+                        inputs: p.inputs.map((i2) => ({ id: i2.id, rev: snapshot.candidates[i2.id] ?? "", ...(i2.supersede === true ? { superseded: true } : {}) })),
+                    },
+                },
+                body: p.body,
+                rev: "",
+            };
+            entry.rev = computeEntryRev(entry);
+            entry.frontmatter.distilled.carrierRev = entry.rev;
+            const nameFinding = scanMemoryFileName(`${slug}.md`);
+            const findings = [...(nameFinding !== undefined ? [nameFinding] : []), ...scanMemoryWrite(serializeEntryFile(entry), { maxBytes: this.perFileBytes })];
+            if (findings.length > 0) {
+                wholeReasons.push(`product #${i}: scan gate (${findings.map((f) => `${f.code}: ${f.reason}`).join("; ")})`);
+                continue;
+            }
+            assembled.push(entry);
+        }
+        const directed = [];
+        const intents = proposal.intents ?? [];
+        const targetIds = intents.map((it) => it.entryId);
+        const targets = new Map((await face.getByIds(targetIds)).map((e) => [e.id, e]));
+        for (const intent of intents) {
+            const committed = targets.get(intent.entryId);
+            if (committed !== undefined && committed.scope !== scope) {
+                wholeReasons.push(`intent ${JSON.stringify(intent.requestId)}: target ${intent.entryId} lives in scope ${JSON.stringify(committed.scope)}, not this plan's ${JSON.stringify(scope)} — one plan, one scope (§3.3)`);
+                continue;
+            }
+            if (committed !== undefined && !consolidationTypeEligible(committed.frontmatter.type)) {
+                wholeReasons.push(`intent ${JSON.stringify(intent.requestId)}: target ${intent.entryId} is ${committed.frontmatter.type} — episodic/procedural entries are never directed-change targets (A-7)`);
+                continue;
+            }
+            if (intent.kind === "forget") {
+                if (committed === undefined || committed.frontmatter.deleted === true) {
+                    directed.push({ intentRequestId: intent.requestId, op: "delete", id: intent.entryId, baseRev: "", state: "satisfied", attribution: "unattributed" });
+                }
+                else {
+                    directed.push({ intentRequestId: intent.requestId, op: "delete", id: intent.entryId, baseRev: committed.rev, state: "pending" });
+                }
+                continue;
+            }
+            if (committed === undefined || committed.frontmatter.deleted === true) {
+                wholeReasons.push(`intent ${JSON.stringify(intent.requestId)}: rewrite target ${intent.entryId} is not committed (a rewrite needs a standing entry; record a new one instead)`);
+                continue;
+            }
+            const terminal = {
+                id: committed.id,
+                slug: committed.slug,
+                scope: committed.scope,
+                frontmatter: {
+                    ...(intent.name !== undefined ? { name: intent.name } : committed.frontmatter.name !== undefined ? { name: committed.frontmatter.name } : {}),
+                    ...(intent.description !== undefined ? { description: intent.description } : committed.frontmatter.description !== undefined ? { description: committed.frontmatter.description } : {}),
+                    ...(intent.type !== undefined ? { type: intent.type } : committed.frontmatter.type !== undefined ? { type: committed.frontmatter.type } : {}),
+                    ...(committed.frontmatter.origin !== undefined ? { origin: { ...committed.frontmatter.origin } } : {}),
+                    ...(committed.frontmatter.distilled !== undefined ? { distilled: structuredClone(committed.frontmatter.distilled) } : {}),
+                    ...(committed.frontmatter.provenance !== undefined ? { provenance: { ...committed.frontmatter.provenance } } : {}),
+                    ...(committed.frontmatter.trust !== undefined ? { trust: committed.frontmatter.trust } : {}),
+                    ...(committed.frontmatter.extra !== undefined ? { extra: [...committed.frontmatter.extra] } : {}),
+                },
+                body: intent.body,
+                rev: "",
+            };
+            terminal.rev = computeEntryRev(terminal);
+            const findings = scanMemoryWrite(serializeEntryFile(terminal), { maxBytes: this.perFileBytes });
+            if (findings.length > 0) {
+                wholeReasons.push(`intent ${JSON.stringify(intent.requestId)}: scan gate (${findings.map((f) => `${f.code}: ${f.reason}`).join("; ")})`);
+                continue;
+            }
+            if (committed.rev === terminal.rev) {
+                directed.push({ intentRequestId: intent.requestId, op: "update", id: intent.entryId, baseRev: committed.rev, plannedPostRev: terminal.rev, entry: terminal, state: "satisfied" });
+            }
+            else {
+                directed.push({ intentRequestId: intent.requestId, op: "update", id: intent.entryId, baseRev: committed.rev, plannedPostRev: terminal.rev, entry: terminal, state: "pending" });
+            }
+        }
+        if (wholeReasons.length > 0)
+            throw new ConsolidationRefusedError("memory.consolidation_refused", "memory consolidation plan refused", wholeReasons);
+        try {
+            const seatNow = readConsolidationGateFile(this.controlDir).scopes[scope]?.openPlanId;
+            if (seatNow !== planId) {
+                throw new ConsolidationRefusedError("memory.consolidation_busy", `memory consolidation refused: the ${JSON.stringify(scope)} seat was reclaimed during the freeze (a reconcile judged the claim stale) — retake the snapshot and commit again.`);
+            }
+        }
+        catch (err) {
+            if (err instanceof ConsolidationRefusedError)
+                throw err;
+            throw new ConsolidationRefusedError("memory.consolidation_gate_corrupt", `memory consolidation refused: the gate store could not be re-read at the freeze boundary (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const plan = {
+            v: 1,
+            planId,
+            scope,
+            requestId: input.requestId,
+            createdAt: at,
+            cycleToken: input.cycleToken,
+            epoch: snapshot.epoch,
+            visibleMarked,
+            ...(foldedOrigin !== undefined ? { foldedOrigin } : {}),
+            products: assembled,
+            productStates: Object.fromEntries(assembled.map((e) => [e.id, "pending"])),
+            directed,
+            intents: intents.map((it) => ({ requestId: it.requestId, state: "pending" })),
+            state: "open",
+            audit: [
+                { at, event: "frozen", requestId: input.requestId, ...(refusedProducts.length > 0 ? { detail: `${refusedProducts.length} product(s) refused at freeze: ${refusedProducts.map((r) => `#${r.index}: ${r.reason}`).join(" | ")}` } : {}) },
+            ],
+        };
+        writeConsolidationPlan(this.controlDir, plan);
+        return { plan, refusedProducts };
+    }
+    async applyConsolidationPlan(plan, frozenLeaseToken) {
+        if (plan.state === "open") {
+            plan.state = "applying";
+            plan.audit.push({ at: this.now(), event: "applying" });
+            writeConsolidationPlan(this.controlDir, plan);
+        }
+        const face = this.committedAuditFace();
+        const pendingProducts = plan.products.filter((p) => plan.productStates[p.id] === "pending");
+        if (pendingProducts.length > 0) {
+            if (!(await this.consolidationLeaseCurrent(plan.scope, frozenLeaseToken))) {
+                throw new ConsolidationRefusedError("memory.consolidation_lease_unavailable", `memory consolidation apply paused: the global lease for scope ${JSON.stringify(plan.scope)} is no longer held at its frozen fencing token — the plan stays durable and replays under a valid holder (reconcileConsolidation).`);
+            }
+            const txnId = uuidv7();
+            const lineageRows = pendingProducts.map((p) => ({ entryId: p.id, rev: p.rev, ...(p.frontmatter.origin !== undefined ? { marked: true } : {}) }));
+            let lineageArmed = false;
+            try {
+                stageLineagePending(this.controlDir, txnId, `consolidation:${plan.planId}`, lineageRows, this.now);
+                lineageArmed = true;
+            }
+            catch (err) {
+                throw new ConsolidationRefusedError("memory.consolidation_governance_unreadable", `memory consolidation apply paused: the lineage write-ahead could not be staged (the plan stays durable and replays): ${err instanceof Error ? err.message : String(err)}`);
+            }
+            let report;
+            try {
+                report = await this.backend.applyPatches(pendingProducts.map(productAddPatch));
+            }
+            catch (err) {
+                try {
+                    discardLineagePending(this.controlDir, txnId);
+                }
+                catch {
+                }
+                throw new ConsolidationRefusedError("memory.consolidation_backend_failed", `memory consolidation apply paused: the backend refused the product batch (the plan stays durable and replays): ${err instanceof Error ? err.message : String(err)}`);
+            }
+            for (const a of report.applied)
+                if (plan.productStates[a.id] === "pending")
+                    plan.productStates[a.id] = "applied";
+            for (const c of report.conflicts) {
+                if (plan.productStates[c.id] === undefined)
+                    continue;
+                const probe = (await face.getByIds([c.id])).find((e) => e.id === c.id);
+                if (probe !== undefined && probe.rev === plan.products.find((p) => p.id === c.id)?.rev) {
+                    plan.productStates[c.id] = "applied";
+                    continue;
+                }
+                plan.productStates[c.id] = "conflict";
+                plan.audit.push({ at: this.now(), event: "product_conflict", detail: `${c.id}: ${c.reason}` });
+            }
+            if (lineageArmed) {
+                try {
+                    recordLineageCredential(this.controlDir, txnId, report.applied.filter((a) => a.op !== "delete").map((a) => a.id), this.now);
+                    this.settlePromotions(promoteLineagePending(this.controlDir, txnId, this.now));
+                }
+                catch (err) {
+                    plan.audit.push({ at: this.now(), event: "lineage_settle_failed", detail: err instanceof Error ? err.message : String(err) });
+                    const sink = this.onIncident;
+                    if (sink !== undefined) {
+                        try {
+                            const e = new Error(`memory consolidation lineage settlement failed after commit (entries stay latched until reconciled): ${err instanceof Error ? err.message : String(err)}`);
+                            e.code = "memory.lineage_settle_failed";
+                            sink(e);
+                        }
+                        catch {
+                        }
+                    }
+                }
+            }
+            writeConsolidationPlan(this.controlDir, plan);
+        }
+        const pendingDirected = plan.directed.filter((d) => d.state === "pending");
+        if (pendingDirected.length > 0) {
+            if (!(await this.consolidationLeaseCurrent(plan.scope, frozenLeaseToken))) {
+                throw new ConsolidationRefusedError("memory.consolidation_lease_unavailable", `memory consolidation apply paused: the global lease for scope ${JSON.stringify(plan.scope)} is no longer held at its frozen fencing token — the plan stays durable and replays under a valid holder (reconcileConsolidation).`);
+            }
+            const patches = pendingDirected.map((d) => (d.op === "delete" ? { op: "delete", id: d.id, baseRev: d.baseRev } : { op: "update", id: d.id, entry: d.entry, baseRev: d.baseRev }));
+            let report;
+            try {
+                report = await this.backend.applyPatches(patches);
+            }
+            catch (err) {
+                throw new ConsolidationRefusedError("memory.consolidation_backend_failed", `memory consolidation apply paused: the backend refused the directed batch (the plan stays durable and replays): ${err instanceof Error ? err.message : String(err)}`);
+            }
+            const appliedIds = new Set(report.applied.map((a) => `${a.op}:${a.id}`));
+            const conflicted = new Map(report.conflicts.map((c) => [`${c.op}:${c.id}`, c]));
+            for (const d of pendingDirected) {
+                const key = `${d.op}:${d.id}`;
+                if (appliedIds.has(key)) {
+                    d.state = "applied";
+                    if (d.op === "delete")
+                        d.attribution = "self";
+                    continue;
+                }
+                const conflict = conflicted.get(key);
+                if (conflict === undefined)
+                    continue;
+                if (d.op === "delete") {
+                    const probe = await face.getByIds([d.id]);
+                    const standing = probe.find((e) => e.id === d.id && e.frontmatter.deleted !== true);
+                    if (standing === undefined) {
+                        d.state = "satisfied";
+                        d.attribution = "unattributed";
+                    }
+                    else {
+                        d.state = "conflict";
+                        plan.audit.push({ at: this.now(), event: "directed_conflict", detail: `${d.id}: ${conflict.reason}` });
+                    }
+                    continue;
+                }
+                const probe = await face.getByIds([d.id]);
+                const current = probe.find((e) => e.id === d.id);
+                if (current !== undefined && current.rev === d.plannedPostRev) {
+                    d.state = "satisfied";
+                }
+                else {
+                    d.state = "conflict";
+                    plan.audit.push({ at: this.now(), event: "directed_conflict", detail: `${d.id}: ${conflict.reason}` });
+                }
+            }
+            writeConsolidationPlan(this.controlDir, plan);
+        }
+        try {
+            const post = this.readChallengeExclusions();
+            for (const p of plan.products) {
+                if (plan.productStates[p.id] !== "applied")
+                    continue;
+                if (post.has(p.id))
+                    continue;
+                const hitInputs = (p.frontmatter.distilled?.inputs ?? []).filter((i) => post.has(i.id)).map((i) => i.id);
+                if (hitInputs.length > 0) {
+                    this.challengeEntries([p.id], `consolidation input ${hitInputs[0]} was challenged in the freeze→apply window (retroactive lineage propagation)`, `consolidation:${plan.planId}:recheck`);
+                    plan.audit.push({ at: this.now(), event: "post_apply_propagation", detail: `${p.id} challenged over inputs ${hitInputs.join(", ")}` });
+                }
+            }
+        }
+        catch (err) {
+            plan.audit.push({ at: this.now(), event: "post_apply_recheck_unreadable", detail: err instanceof Error ? err.message : String(err) });
+        }
+        return await this.settleConsolidationPlan(plan);
+    }
+    async settleConsolidationPlan(plan) {
+        const productStates = Object.values(plan.productStates);
+        const anyConflict = productStates.includes("conflict") || plan.directed.some((d) => d.state === "conflict");
+        const allTerminal = productStates.every((s) => s !== "pending") && plan.directed.every((d) => d.state !== "pending");
+        if (!allTerminal) {
+            writeConsolidationPlan(this.controlDir, plan);
+            throw new ConsolidationRefusedError("memory.consolidation_backend_failed", `memory consolidation plan ${plan.planId} did not reach terminal state this pass — it stays durable and replays (reconcileConsolidation).`);
+        }
+        const at = this.now();
+        const notices = [];
+        if (anyConflict) {
+            plan.state = "conflict";
+            plan.audit.push({ at, event: "conflict" });
+            writeConsolidationPlan(this.controlDir, plan);
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at, items: [`memory consolidation plan ${plan.planId} for scope ${inlineUntrusted(plan.scope, 80)} parked CONFLICT — resolveConsolidationPlan(planId, "retry"|"discard") is the host valve`] });
+            }
+            catch (err) {
+                this.discloseAnnounceFailure("consolidation conflict enqueue", err);
+            }
+            notices.push(memoryConsolidationConflictNotice({ planId: plan.planId, scope: plan.scope }));
+            return this.consolidationReceipt(plan, notices);
+        }
+        plan.state = "completed";
+        plan.audit.push({ at, event: "completed" });
+        const credentialRows = plan.intents.map((it) => ({
+            requestId: it.requestId,
+            state: "settled",
+            planId: plan.planId,
+            at,
+            patches: plan.directed.filter((d) => d.intentRequestId === it.requestId).map((d) => ({ op: d.op, id: d.id, ...(d.attribution !== undefined ? { attribution: d.attribution } : {}) })),
+        }));
+        try {
+            const written = new Set(recordIntentCredentials(this.controlDir, credentialRows));
+            for (const it of plan.intents)
+                it.state = "settled";
+            for (const row2 of credentialRows) {
+                if (!written.has(row2.requestId)) {
+                    plan.audit.push({ at, event: "credential_preowned", detail: `${row2.requestId}: another plan's credential stands (terminal-state effects converged; the standing row wins, F10)` });
+                }
+            }
+        }
+        catch (err) {
+            plan.state = "applying";
+            plan.audit.push({ at, event: "credential_write_failed", detail: err instanceof Error ? err.message : String(err) });
+            writeConsolidationPlan(this.controlDir, plan);
+            throw new ConsolidationRefusedError("memory.consolidation_governance_unreadable", `memory consolidation plan ${plan.planId} committed its writes but could not record the intent credentials — the plan stays durable and replays (reconcileConsolidation): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        writeConsolidationPlan(this.controlDir, plan);
+        const currentlyEligible = await this.settleFingerprintFilter(plan.scope);
+        updateConsolidationGate(this.controlDir, (file) => {
+            const row = file.scopes[plan.scope];
+            if (row?.openPlanId !== plan.planId)
+                return { result: undefined };
+            delete row.openPlanId;
+            row.lastRunAt = at;
+            row.epoch += 1;
+            row.sessions = { count: 0, ring: [] };
+            if (row.snapshot !== undefined) {
+                if (currentlyEligible !== undefined) {
+                    const fp = {};
+                    for (const [id, rev] of Object.entries(row.snapshot.eligible)) {
+                        if (!currentlyEligible(id, rev))
+                            continue;
+                        fp[id] = { rev };
+                    }
+                    row.fingerprint = fp;
+                }
+                else {
+                    delete row.fingerprint;
+                }
+                delete row.snapshot;
+            }
+            file.scopes[plan.scope] = row;
+            return { next: file, result: undefined };
+        });
+        const productCount = Object.values(plan.productStates).filter((s) => s === "applied").length;
+        const supersededCount = new Set(plan.products.flatMap((p) => (p.frontmatter.distilled?.inputs ?? []).filter((i) => i.superseded === true).map((i) => i.id))).size;
+        try {
+            enqueueMemoryAnnouncement(this.controlDir, {
+                kind: "gate",
+                at,
+                items: [`memory consolidation plan ${plan.planId} for scope ${inlineUntrusted(plan.scope, 80)} COMPLETED: ${productCount} product(s) committed, ${supersededCount} entr${supersededCount === 1 ? "y" : "ies"} superseded (evidence retained), ${plan.intents.length} intent(s) settled`],
+            });
+        }
+        catch (err) {
+            this.discloseAnnounceFailure("consolidation completion enqueue", err);
+        }
+        notices.push(memoryConsolidationCommittedNotice({ planId: plan.planId, scope: plan.scope, products: productCount, superseded: supersededCount, intents: plan.intents.length }));
+        return this.consolidationReceipt(plan, notices);
+    }
+    consolidationReceipt(plan, notices) {
+        const states = Object.values(plan.productStates);
+        return {
+            planId: plan.planId,
+            state: plan.state === "completed" ? "completed" : "conflict",
+            products: { frozen: plan.products.length, applied: states.filter((s) => s === "applied").length, conflicts: states.filter((s) => s === "conflict").length, refused: [] },
+            directed: {
+                frozen: plan.directed.length,
+                applied: plan.directed.filter((d) => d.state === "applied").length,
+                satisfied: plan.directed.filter((d) => d.state === "satisfied").length,
+                conflicts: plan.directed.filter((d) => d.state === "conflict").length,
+            },
+            intents: { settled: plan.intents.filter((i) => i.state === "settled").map((i) => i.requestId), pending: plan.intents.filter((i) => i.state === "pending").map((i) => i.requestId) },
+            foldedOrigin: plan.foldedOrigin !== undefined,
+            notices,
+        };
+    }
+    async reconcileConsolidation(scope) {
+        this.requireConsolidation();
+        const gate = this.readConsolidationGateOrRefuse();
+        const row = gate.scopes[scope];
+        const out = { propagatedChallenges: [] };
+        if (row?.openPlanId !== undefined) {
+            const seated = row.openPlanId;
+            const read = readConsolidationPlan(this.controlDir, seated);
+            if (read.state === "absent") {
+                if (this.now() - (row.seatClaimedAt ?? 0) < CONSOLIDATION_SEAT_FREEZE_GRACE_MS) {
+                    out.seatInFlight = seated;
+                }
+                else {
+                    this.releaseOrphanConsolidationSeat(scope, seated, out);
+                }
+            }
+            else if (read.state === "corrupt") {
+                out.corruptPlan = { planId: seated, detail: read.detail };
+            }
+            else if (read.plan.state === "open" || read.plan.state === "applying") {
+                try {
+                    const receipt = await this.applyConsolidationPlan(read.plan);
+                    out.replayed = { planId: seated, state: receipt.state };
+                }
+                finally {
+                    await this.releaseConsolidationLease(scope);
+                }
+            }
+            else if (read.plan.state === "completed" || read.plan.state === "discarded") {
+                await this.settleGateForTerminalPlan(read.plan);
+                out.replayed = { planId: seated, state: read.plan.state === "completed" ? "completed" : "conflict" };
+            }
+        }
+        await this.runConsolidationPropagationSweep(scope, out);
+        return out;
+    }
+    releaseOrphanConsolidationSeat(scope, seated, out) {
+        updateConsolidationGate(this.controlDir, (file) => {
+            const r = file.scopes[scope];
+            if (r?.openPlanId === seated) {
+                delete r.openPlanId;
+                file.scopes[scope] = r;
+                return { next: file, result: undefined };
+            }
+            return { result: undefined };
+        });
+        try {
+            enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at: this.now(), items: [`memory consolidation seat for scope ${inlineUntrusted(scope, 80)} released: plan ${seated} was lost before freeze (crash window) — nothing was applied`] });
+        }
+        catch (err) {
+            this.discloseAnnounceFailure("consolidation orphan-seat enqueue", err);
+        }
+        out.releasedOrphanSeat = seated;
+    }
+    async runConsolidationPropagationSweep(scope, out) {
+        try {
+            const face = this.committedAuditFace();
+            const headers = await face.listHeaders([scope]);
+            const exclusions = this.readChallengeExclusions();
+            const productHeaders = headers.filter((h) => h.distilled !== undefined && !exclusions.has(h.id));
+            if (productHeaders.length > 0) {
+                const products = await face.getByIds(productHeaders.map((h) => h.id));
+                for (const p of products) {
+                    const challengedInputs = (p.frontmatter.distilled?.inputs ?? []).filter((i) => exclusions.get(i.id)?.code === "challenged").map((i) => i.id);
+                    if (challengedInputs.length === 0)
+                        continue;
+                    this.challengeEntries([p.id], `consolidation input ${challengedInputs[0]} is challenged (retroactive lineage propagation — the product distilled from it)`, `consolidation-reconcile:${uuidv7()}`);
+                    out.propagatedChallenges.push(p.id);
+                }
+            }
+        }
+        catch (err) {
+            out.sweepError = err instanceof Error ? err.message : String(err);
+        }
+    }
+    async settleGateForTerminalPlan(plan) {
+        const currentlyEligible = await this.settleFingerprintFilter(plan.scope);
+        updateConsolidationGate(this.controlDir, (file) => {
+            const row = file.scopes[plan.scope];
+            if (row?.openPlanId !== plan.planId)
+                return { result: undefined };
+            delete row.openPlanId;
+            row.epoch += 1;
+            if (plan.state === "completed") {
+                row.lastRunAt = this.now();
+                row.sessions = { count: 0, ring: [] };
+                if (row.snapshot !== undefined) {
+                    if (currentlyEligible !== undefined) {
+                        const fp = {};
+                        for (const [id, rev] of Object.entries(row.snapshot.eligible)) {
+                            if (!currentlyEligible(id, rev))
+                                continue;
+                            fp[id] = { rev };
+                        }
+                        row.fingerprint = fp;
+                    }
+                    else {
+                        delete row.fingerprint;
+                    }
+                }
+            }
+            delete row.snapshot;
+            file.scopes[plan.scope] = row;
+            return { next: file, result: undefined };
+        });
+    }
+    async settleFingerprintFilter(scope) {
+        try {
+            const headers = await this.committedAuditFace().listHeaders([scope]);
+            const excl = this.readChallengeExclusions();
+            const sup = deriveSupersededSet(headers, { excluded: (id) => excl.has(id) });
+            const revById = new Map(headers.map((h) => [h.id, h.rev]));
+            return (id, rev) => !excl.has(id) && !sup.has(id) && revById.get(id) === rev;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async resolveConsolidationPlan(planId, action, opts) {
+        this.requireConsolidation();
+        if (!isValidConsolidationPlanId(planId)) {
+            throw new ConsolidationRefusedError("memory.consolidation_refused", `memory consolidation plan id ${JSON.stringify(planId.slice(0, 80))} fails the plan-id grammar — refused before any path use.`);
+        }
+        const read = readConsolidationPlan(this.controlDir, planId);
+        const at = this.now();
+        if (read.state === "corrupt") {
+            if (action === "retry") {
+                throw new ConsolidationRefusedError("memory.consolidation_refused", `memory consolidation plan ${planId} is corrupt (${read.detail}) — retry has no readable intents; discard it (the bytes move to custody).`);
+            }
+            const custody = quarantineCorruptPlan(this.controlDir, planId);
+            updateConsolidationGate(this.controlDir, (file) => {
+                for (const [scope, row] of Object.entries(file.scopes)) {
+                    if (row.openPlanId === planId) {
+                        delete row.openPlanId;
+                        row.epoch += 1;
+                        delete row.snapshot;
+                        file.scopes[scope] = row;
+                        return { next: file, result: undefined };
+                    }
+                }
+                return { result: undefined };
+            });
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at, items: [`memory consolidation plan ${planId} DISCARDED as corrupt (requestId ${inlineUntrusted(opts.requestId, 80)})${custody !== undefined ? ` — bytes retained at ${custody}` : ""}`] });
+            }
+            catch (err) {
+                this.discloseAnnounceFailure("consolidation corrupt-discard enqueue", err);
+            }
+            return { planId, action, state: "discarded", ...(custody !== undefined ? { custody } : {}) };
+        }
+        if (read.state === "absent") {
+            throw new ConsolidationRefusedError("memory.consolidation_refused", `memory consolidation plan ${planId} does not exist.`);
+        }
+        const plan = read.plan;
+        if (plan.state === "completed" || plan.state === "discarded") {
+            throw new ConsolidationRefusedError("memory.consolidation_refused", `memory consolidation plan ${planId} is already terminal (${plan.state}) — a late valve action is refused (状态先读后写).`);
+        }
+        if (action === "discard") {
+            plan.state = "discarded";
+            plan.audit.push({ at, event: "discarded", requestId: opts.requestId });
+            const abandoned = plan.intents.filter((i) => i.state === "pending");
+            for (const it of abandoned)
+                it.state = "abandoned";
+            writeConsolidationPlan(this.controlDir, plan);
+            try {
+                recordIntentCredentials(this.controlDir, abandoned.map((it) => ({ requestId: it.requestId, state: "abandoned", planId, at, patches: [] })));
+            }
+            catch (err) {
+                plan.audit.push({ at, event: "abandon_credential_failed", detail: err instanceof Error ? err.message : String(err) });
+                writeConsolidationPlan(this.controlDir, plan);
+            }
+            await this.settleGateForTerminalPlan(plan);
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at, items: [`memory consolidation plan ${planId} DISCARDED by the host valve (requestId ${inlineUntrusted(opts.requestId, 80)}) — ${abandoned.length} intent(s) settled ABANDONED (given up, not fulfilled)`] });
+            }
+            catch (err) {
+                this.discloseAnnounceFailure("consolidation discard enqueue", err);
+            }
+            return { planId, action, state: "discarded", abandonedIntents: abandoned.map((i) => i.requestId) };
+        }
+        if (plan.state !== "conflict") {
+            throw new ConsolidationRefusedError("memory.consolidation_refused", `memory consolidation plan ${planId} is ${plan.state} — retry acts on a CONFLICT plan (run reconcileConsolidation to converge an in-flight one).`);
+        }
+        let standingCredentials = {};
+        try {
+            standingCredentials = readIntentCredentials(this.controlDir);
+        }
+        catch (err) {
+            throw new ConsolidationRefusedError("memory.consolidation_gate_corrupt", `memory consolidation retry refused: the intent-credential account cannot be trusted (fail-closed): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const pendingIntents = plan.intents.filter((i) => i.state === "pending" && standingCredentials[i.requestId] === undefined).map((i) => i.requestId);
+        const face = this.committedAuditFace();
+        const originalIntents = await this.reconstructIntentsForRetry(plan, pendingIntents, face);
+        const retryPlanId = uuidv7();
+        updateConsolidationGate(this.controlDir, (file) => {
+            const row = file.scopes[plan.scope] ?? { sessions: { count: 0, ring: [] }, epoch: 0 };
+            if (row.openPlanId !== plan.planId && row.openPlanId !== undefined) {
+                throw new ConsolidationRefusedError("memory.consolidation_busy", `memory consolidation retry refused: plan ${row.openPlanId} holds the ${JSON.stringify(plan.scope)} seat.`);
+            }
+            row.openPlanId = retryPlanId;
+            row.seatClaimedAt = at;
+            file.scopes[plan.scope] = row;
+            return { next: file, result: undefined };
+        });
+        const retryPlan = {
+            v: 1,
+            planId: retryPlanId,
+            scope: plan.scope,
+            requestId: opts.requestId,
+            createdAt: at,
+            epoch: 0,
+            visibleMarked: false,
+            products: [],
+            productStates: {},
+            directed: originalIntents.directed,
+            intents: pendingIntents.map((r) => ({ requestId: r, state: "pending" })),
+            state: "open",
+            audit: [
+                { at, event: "frozen_retry", requestId: opts.requestId, detail: `retries intents of ${planId}` },
+                ...originalIntents.reasons.map((r) => ({ at, event: "directed_conflict", detail: `${r.id}: ${r.reason}` })),
+            ],
+        };
+        writeConsolidationPlan(this.controlDir, retryPlan);
+        plan.state = "discarded";
+        plan.audit.push({ at, event: "superseded_by_retry", requestId: opts.requestId, detail: `retried as ${retryPlanId}` });
+        writeConsolidationPlan(this.controlDir, plan);
+        try {
+            const receipt = await this.applyConsolidationPlan(retryPlan);
+            return { planId, action, state: receipt.state, retryPlanId, retryReceipt: receipt };
+        }
+        finally {
+            await this.releaseConsolidationLease(plan.scope);
+        }
+    }
+    async reconstructIntentsForRetry(plan, pendingIntentIds, face) {
+        const directed = [];
+        const reasons = [];
+        const wanted = new Set(pendingIntentIds);
+        const targets = new Map((await face.getByIds(plan.directed.filter((d) => wanted.has(d.intentRequestId)).map((d) => d.id))).map((e) => [e.id, e]));
+        for (const d of plan.directed) {
+            if (!wanted.has(d.intentRequestId))
+                continue;
+            const committed = targets.get(d.id);
+            if (committed !== undefined && committed.scope !== plan.scope) {
+                directed.push({ intentRequestId: d.intentRequestId, op: d.op, id: d.id, baseRev: "", ...(d.plannedPostRev !== undefined ? { plannedPostRev: d.plannedPostRev } : {}), state: "conflict" });
+                reasons.push({ id: d.id, reason: `target now lives in scope ${JSON.stringify(committed.scope)}, not this plan's ${JSON.stringify(plan.scope)} — no patch was offered to the store` });
+                continue;
+            }
+            if (d.op === "delete") {
+                if (committed === undefined || committed.frontmatter.deleted === true) {
+                    directed.push({ intentRequestId: d.intentRequestId, op: "delete", id: d.id, baseRev: "", state: "satisfied", attribution: "unattributed" });
+                }
+                else {
+                    directed.push({ intentRequestId: d.intentRequestId, op: "delete", id: d.id, baseRev: committed.rev, state: "pending" });
+                }
+                continue;
+            }
+            if (d.entry === undefined) {
+                const satisfied = committed !== undefined && committed.rev === d.plannedPostRev;
+                directed.push({ intentRequestId: d.intentRequestId, op: "update", id: d.id, baseRev: "", ...(d.plannedPostRev !== undefined ? { plannedPostRev: d.plannedPostRev } : {}), state: satisfied ? "satisfied" : "conflict" });
+                if (!satisfied)
+                    reasons.push({ id: d.id, reason: "the frozen row carries no terminal entry to replay and the committed rev is not the planned one — no patch was offered to the store" });
+                continue;
+            }
+            if (committed === undefined || committed.frontmatter.deleted === true) {
+                directed.push({ intentRequestId: d.intentRequestId, op: "update", id: d.id, baseRev: "", ...(d.plannedPostRev !== undefined ? { plannedPostRev: d.plannedPostRev } : {}), state: "conflict" });
+                reasons.push({ id: d.id, reason: "the rewrite target is gone (absent or tombstoned) — a terminal cannot stand on a missing entry, and no patch was offered to the store" });
+                continue;
+            }
+            if (committed.rev === d.plannedPostRev) {
+                directed.push({ intentRequestId: d.intentRequestId, op: "update", id: d.id, baseRev: committed.rev, ...(d.plannedPostRev !== undefined ? { plannedPostRev: d.plannedPostRev } : {}), state: "satisfied" });
+            }
+            else {
+                directed.push({ intentRequestId: d.intentRequestId, op: "update", id: d.id, baseRev: committed.rev, ...(d.plannedPostRev !== undefined ? { plannedPostRev: d.plannedPostRev } : {}), entry: d.entry, state: "pending" });
+            }
+        }
+        return { directed, reasons };
+    }
+    listConsolidationPlans() {
+        const out = [];
+        for (const planId of listConsolidationPlanIds(this.controlDir)) {
+            const read = readConsolidationPlan(this.controlDir, planId);
+            if (read.state === "corrupt") {
+                out.push({ planId, corrupt: true });
+                continue;
+            }
+            if (read.state === "absent")
+                continue;
+            const p = read.plan;
+            out.push({ planId, scope: p.scope, state: p.state, createdAt: p.createdAt, products: p.products.length, directed: p.directed.length, intents: p.intents.length });
+        }
+        return out;
+    }
+    readConsolidationGate(scope) {
+        try {
+            return readConsolidationGateFile(this.controlDir).scopes[scope];
+        }
+        catch {
+            return undefined;
+        }
+    }
     committedAuditFace() {
         const b = this.backend;
         return b.restrictedAdoptionView?.({ audit: false }) ?? b.retrievalView?.() ?? this.backend;
@@ -2608,6 +3703,8 @@ export class MemoryEngine {
         const carryIndex = this.provenance === "carry";
         const exposedById = new Map();
         const exposedProjectionTargets = new Set();
+        const supersededIds = deriveSupersededSet(headers, { excluded: (id) => excludedIds.has(id) });
+        const supersededTargets = new Set();
         for (const h of headers) {
             const repoTarget = handle.repoIndexTargets?.get(h.id);
             const target = repoTarget ?? relative(handle.writableRoot, canonicalize(join(scopeDirFor(this.memoryDir, this.controlDir, h.scope), `${h.slug}.md`)));
@@ -2615,11 +3712,17 @@ export class MemoryEngine {
                 excludedTargets.add(target);
                 continue;
             }
+            const superseded = supersededIds.has(h.id);
             if (carryIndex && h.exposure === "external") {
-                exposedById.set(h.id, h);
+                if (!superseded)
+                    exposedById.set(h.id, h);
                 exposedProjectionTargets.add(target);
                 continue;
             }
+            if (superseded) {
+                supersededTargets.add(target);
+                continue;
+            }
             expected.set(target, h);
         }
         const covered = new Set();
@@ -2637,7 +3740,7 @@ export class MemoryEngine {
             return prev;
         };
         const foldTarget = (t) => foldDots(t.toLowerCase());
-        const knownTargetsFolded = new Set([...expected.keys(), ...excludedTargets, ...exposedProjectionTargets].map(foldTarget));
+        const knownTargetsFolded = new Set([...expected.keys(), ...excludedTargets, ...exposedProjectionTargets, ...supersededTargets].map(foldTarget));
         const pathTokenAt = (folded, idx, len) => {
             const isPathChar = (ch) => /[a-z0-9._\-/\\]/.test(ch);
             let s = idx;
@@ -2685,6 +3788,10 @@ export class MemoryEngine {
                 warnings?.push(`MEMORY.md index line removed: ${target} is withheld (challenged or unsettled) — its content stays off the injected index`);
                 continue;
             }
+            if (supersededTargets.has(target)) {
+                warnings?.push(`MEMORY.md index line for ${target} removed: a newer consolidated entry supersedes it (the entry stays readable via memory_get)`);
+                continue;
+            }
             if (covered.has(target)) {
                 if (line === keptByTarget.get(target))
                     continue;