@sema-agent/core 5.53.0 → 5.55.0

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

@@ -77,6 +77,15 @@ function entryInvalid(raw, scopes) {
             return `entry ${JSON.stringify(e.id)} frontmatter.origin is malformed`;
         }
     }
+    if (fm.distilled !== undefined) {
+        const d = fm.distilled;
+        const inputsOk = (v) => Array.isArray(v) &&
+            v.length > 0 &&
+            v.every((row) => isRecord(row) && typeof row.id === "string" && row.id.length > 0 && typeof row.rev === "string" && row.rev.length > 0 && (row.superseded === undefined || row.superseded === true));
+        if (!isRecord(d) || typeof d.planId !== "string" || d.planId.length === 0 || typeof d.at !== "number" || !Number.isFinite(d.at) || typeof d.carrierRev !== "string" || d.carrierRev.length === 0 || !inputsOk(d.inputs)) {
+            return `entry ${JSON.stringify(e.id)} frontmatter.distilled is malformed`;
+        }
+    }
     if (ambiguousOriginRepresentation(fm)) {
         return `entry ${JSON.stringify(e.id)} carries conflicting or duplicated origin representations (ambiguous marker representation)`;
     }

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

@@ -4,7 +4,7 @@ import { dirname, join, relative } from "node:path";
 import { jaccardDistance, termSet } from "../memory-vector.js";
 import { MAX_MEMORY_BYTES } from "../memory.js";
 import { inlineUntrusted } from "../untrusted-text.js";
-import { ambiguousOriginRepresentation, committedOriginOf, computeEntryRev, entryFromFile, isValidEntryId, originEquals, parseEntryFile, serializeEntryFile } from "./frontmatter.js";
+import { ambiguousOriginRepresentation, committedDistilledOf, committedOriginOf, computeEntryRev, distilledEquals, entryFromFile, isValidEntryId, originEquals, parseEntryFile, serializeEntryFile } from "./frontmatter.js";
 import { ControlPlaneCorruptError, CURSORS_FILE, QUARANTINE_DIR, CHALLENGES_FILE, IMPORT_RECEIPTS_DIR, LINEAGE_FILE, SESSION_POLLUTION_DIR, appendChallengeEvents, atomicWriteFileSync, quarantineAndTombstone, captureAndClearLineageForEntries, claimRootScope, adoptCanonicalKeyedControlDir, deriveControlPlaneDir, ensureDirExists, enqueueMemoryAnnouncement, importLatchTxnId, importLineageCommitted, importSessionPollution, isContainedIn, lineageContributionsOfSession, listSessionPollution, readChallengeEvents, readLineageRecord, registerScope, registeredScopes, releaseImportLatch, resolveMemoryEngineRoot, scopeDirFor, scopeDirName, stageImportLatch, writeAllSync, } from "./layout.js";
 import { screenInboundEntries } from "./data-plane.js";
 import { scanMemoryFileName, scanMemoryWrite } from "./scan.js";
@@ -2403,6 +2403,15 @@ export class FileMemoryEngineBackend {
                     });
                     return;
                 }
+                const committedDistilled = committedDistilledOf(committedFm);
+                if (committedDistilled !== undefined && !distilledEquals(committedDistilled, committedDistilledOf(entry.frontmatter))) {
+                    report.conflicts.push({
+                        op: "add",
+                        id: patch.id,
+                        reason: `distilled lineage whitewash refused: the add strips or rewrites the distilled block of a consolidation product (malformed patch refused)`,
+                    });
+                    return;
+                }
             }
             if (patch.guard === "absent") {
                 if (existingAnywhere) {
@@ -2490,6 +2499,15 @@ export class FileMemoryEngineBackend {
                 });
                 return;
             }
+            const committedDistilled = committedDistilledOf(committedFm);
+            if (committedDistilled !== undefined && !distilledEquals(committedDistilled, committedDistilledOf(patch.entry.frontmatter))) {
+                report.conflicts.push({
+                    op: "update",
+                    id: patch.id,
+                    reason: `distilled lineage whitewash refused: the update strips or rewrites the distilled block of a consolidation product (malformed patch refused)`,
+                });
+                return;
+            }
         }
         const currentRev = rowsRev(rows, patch.id) ?? found.entry.rev;
         if (patch.baseRev !== undefined && patch.baseRev !== currentRev) {
@@ -3696,6 +3714,14 @@ function headerOf(e, path) {
         rev: e.rev,
         sizeBytes: Buffer.byteLength(serializeEntryFile(e), "utf8"),
         ...(committedOriginOf(e.frontmatter) !== undefined ? { exposure: "external" } : {}),
+        ...(e.frontmatter.distilled !== undefined
+            ? {
+                distilled: {
+                    carrierRev: e.frontmatter.distilled.carrierRev,
+                    supersedes: e.frontmatter.distilled.inputs.filter((i) => i.superseded === true).map((i) => ({ id: i.id, rev: i.rev })),
+                },
+            }
+            : {}),
     };
 }
 function readSafe(path) {

package/dist/core/memory-engine/frontmatter.d.ts

@@ -1,4 +1,4 @@
-import { type MemoryEntry, type MemoryEntryFrontmatter, type MemoryEntryOrigin } from "./types.js";
+import { type MemoryEntry, type MemoryEntryDistilled, type MemoryEntryFrontmatter, type MemoryEntryOrigin } from "./types.js";
 /** A parsed entry file: frontmatter (may be absent — CC allows bare files; harvest mints them) + body. */
 export interface ParsedEntryFile {
     /** The hidden immutable id (`id:` frontmatter line), when present. */
@@ -92,5 +92,24 @@ export declare function ambiguousOriginRepresentation(fm: Pick<MemoryEntryFrontm
  * caller discloses via a report warning).
  */
 export declare function stripModelWrittenOrigin(fm: MemoryEntryFrontmatter): boolean;
+/** True ⇔ `extra` carries distilled-form bytes (a non-pristine/foreign block preserved verbatim). */
+export declare function hasDistilledFormExtra(fm: Pick<MemoryEntryFrontmatter, "extra">): boolean;
+/** The ONE reading of an entry's committed distilled block: the typed seat or nothing. Extra-form
+ *  bytes deliberately do NOT answer here (they mint no edge — fewer edges is the safe direction
+ *  for a suppression carrier). Returns a defensive copy. */
+export declare function committedDistilledOf(fm: Pick<MemoryEntryFrontmatter, "distilled">): MemoryEntryDistilled | undefined;
+/** Deep equality over the distilled block (every member, input order included) — the immutability
+ *  law's comparator: a rewritten carrierRev, a dropped input row or a flipped superseded flag is as
+ *  refused as a strip. */
+export declare function distilledEquals(a: MemoryEntryDistilled | undefined, b: MemoryEntryDistilled | undefined): boolean;
+/**
+ * design/339 §1.4.2-1 — the harvest-side STRIP of model-written distilled bytes (typed field AND
+ * distilled-form `extra` lines): the block is minted by the consolidation plan freeze EXCLUSIVELY —
+ * whatever a file on the model-writable plane says about its own lineage/supersession is not
+ * evidence (a model-writable edge would be the delete-attack channel add-only exists to close).
+ * Same seat and same disclosure discipline as {@link stripModelWrittenOrigin}. MUTATES the given
+ * (already-copied) frontmatter; returns true ⇔ anything was stripped.
+ */
+export declare function stripModelWrittenDistilled(fm: MemoryEntryFrontmatter): boolean;
 /** Parse a file's text directly into a full MemoryEntry (id must already be present/decided). */
 export declare function entryFromFile(text: string, id: string, slug: string, scope: string): MemoryEntry;

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

@@ -37,6 +37,10 @@ export function parseEntryFile(text) {
     const originRaw = [];
     let originPristine = true;
     const orig = {};
+    let inDistilled = false;
+    const distilledRaw = [];
+    let distilledPristine = true;
+    const dist = { inputs: [] };
     for (let i = 1; i < end; i++) {
         const line = lines[i] ?? "";
         const trimmed = line.trim();
@@ -47,6 +51,7 @@ export function parseEntryFile(text) {
             inMetadata = false;
             inProvenance = false;
             inOrigin = false;
+            inDistilled = false;
         }
         if (inMetadata) {
             const m = /^\s+type:\s*(.+?)\s*$/.exec(line);
@@ -101,6 +106,35 @@ export function parseEntryFile(text) {
             }
             continue;
         }
+        if (inDistilled) {
+            distilledRaw.push(line);
+            const m = /^\s+([A-Za-z][A-Za-z0-9_-]*):\s*(.*?)\s*$/.exec(line);
+            if (m) {
+                const [, k = "", v = ""] = m;
+                if (k === "planId" && dist.planId === undefined && /^\S+$/.test(v))
+                    dist.planId = v;
+                else if (k === "at" && dist.at === undefined && ORIGIN_AT_RE.test(v))
+                    dist.at = Number(v);
+                else if (k === "carrierRev" && dist.carrierRev === undefined && /^\S+$/.test(v))
+                    dist.carrierRev = v;
+                else if (k === "input") {
+                    const parts = v.split(/\s+/);
+                    const [inId, inRev, flag, ...rest] = parts;
+                    if (inId !== undefined && isValidEntryId(inId) && inRev !== undefined && /^\S+$/.test(inRev) && rest.length === 0 && (flag === undefined || flag === "superseded")) {
+                        dist.inputs.push({ id: inId, rev: inRev, ...(flag === "superseded" ? { superseded: true } : {}) });
+                    }
+                    else {
+                        distilledPristine = false;
+                    }
+                }
+                else
+                    distilledPristine = false;
+            }
+            else {
+                distilledPristine = false;
+            }
+            continue;
+        }
         if (/^provenance:\s*$/.test(trimmed)) {
             inProvenance = true;
             provRaw.push(line);
@@ -111,6 +145,11 @@ export function parseEntryFile(text) {
             originRaw.push(line);
             continue;
         }
+        if (/^distilled:\s*$/.test(trimmed) && distilledRaw.length === 0) {
+            inDistilled = true;
+            distilledRaw.push(line);
+            continue;
+        }
         const kv = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*?)\s*$/.exec(trimmed);
         if (!kv || indented) {
             extra.push(line);
@@ -172,6 +211,14 @@ export function parseEntryFile(text) {
             extra.push(...originRaw);
         }
     }
+    if (distilledRaw.length > 0) {
+        if (distilledPristine && dist.planId !== undefined && typeof dist.at === "number" && atSerializationStable(dist.at) && dist.carrierRev !== undefined && dist.inputs.length > 0) {
+            fm.distilled = { planId: dist.planId, at: dist.at, carrierRev: dist.carrierRev, inputs: dist.inputs };
+        }
+        else {
+            extra.push(...distilledRaw);
+        }
+    }
     if (extra.length > 0)
         fm.extra = extra;
     let body = lines.slice(end + 1).join("\n");
@@ -200,6 +247,9 @@ export function serializeEntryFile(entry) {
     if (fm.origin !== undefined) {
         lines.push("origin:", `  taint: ${fm.origin.taint}`, ...(fm.origin.cause !== undefined ? [`  cause: ${fm.origin.cause}`] : []), `  at: ${fm.origin.at}`);
     }
+    if (fm.distilled !== undefined) {
+        lines.push("distilled:", `  planId: ${fm.distilled.planId}`, `  at: ${fm.distilled.at}`, `  carrierRev: ${fm.distilled.carrierRev}`, ...fm.distilled.inputs.map((i) => `  input: ${i.id} ${i.rev}${i.superseded === true ? " superseded" : ""}`));
+    }
     lines.push(FM_FENCE, "");
     const body = entry.body.replace(/\s+$/, "");
     return `${lines.join("\n")}${body}${body ? "\n" : ""}`;
@@ -220,6 +270,7 @@ export function computeEntryRev(entry) {
             ? [fm.trust ?? null, fm.provenance !== undefined ? [fm.provenance.kind, fm.provenance.path, fm.provenance.contentHash, fm.provenance.ingestedAt] : null]
             : []),
         ...(canonicalOrigin !== undefined ? [["origin", canonicalOrigin.taint, canonicalOrigin.cause ?? null, canonicalOrigin.at]] : []),
+        ...(fm.distilled !== undefined ? [["distilled", fm.distilled.planId, fm.distilled.at, fm.distilled.inputs.map((i) => [i.id, i.rev, i.superseded === true ? 1 : 0])]] : []),
     ]);
     return createHash("sha256").update(canonical, "utf8").digest("hex").slice(0, 16);
 }
@@ -325,6 +376,66 @@ export function stripModelWrittenOrigin(fm) {
     }
     return stripped;
 }
+const DISTILLED_FORM_LINE_RE = /^\s*distilled\s*:/;
+export function hasDistilledFormExtra(fm) {
+    return fm.extra !== undefined && fm.extra.some((line) => DISTILLED_FORM_LINE_RE.test(line));
+}
+export function committedDistilledOf(fm) {
+    const d = fm.distilled;
+    if (d === undefined)
+        return undefined;
+    return { planId: d.planId, at: d.at, carrierRev: d.carrierRev, inputs: d.inputs.map((i) => ({ id: i.id, rev: i.rev, ...(i.superseded === true ? { superseded: true } : {}) })) };
+}
+export function distilledEquals(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    if (a.planId !== b.planId || a.at !== b.at || a.carrierRev !== b.carrierRev || a.inputs.length !== b.inputs.length)
+        return false;
+    for (let i = 0; i < a.inputs.length; i++) {
+        const x = a.inputs[i];
+        const y = b.inputs[i];
+        if (x.id !== y.id || x.rev !== y.rev || (x.superseded === true) !== (y.superseded === true))
+            return false;
+    }
+    return true;
+}
+function partitionDistilledLines(extra) {
+    const kept = [];
+    let removedAny = false;
+    let inBlock = false;
+    for (const line of extra) {
+        if (DISTILLED_FORM_LINE_RE.test(line)) {
+            inBlock = /^\s*distilled\s*:\s*$/.test(line);
+            removedAny = true;
+            continue;
+        }
+        if (inBlock && /^\s/.test(line)) {
+            removedAny = true;
+            continue;
+        }
+        inBlock = false;
+        kept.push(line);
+    }
+    return { kept, removedAny };
+}
+export function stripModelWrittenDistilled(fm) {
+    let stripped = false;
+    if (fm.distilled !== undefined) {
+        delete fm.distilled;
+        stripped = true;
+    }
+    if (fm.extra !== undefined) {
+        const { kept, removedAny } = partitionDistilledLines(fm.extra);
+        if (removedAny) {
+            stripped = true;
+            if (kept.length > 0)
+                fm.extra = kept;
+            else
+                delete fm.extra;
+        }
+    }
+    return stripped;
+}
 export function entryFromFile(text, id, slug, scope) {
     const parsed = parseEntryFile(text);
     const entry = { id, slug, frontmatter: parsed.frontmatter, body: parsed.body, rev: "", scope };

package/dist/core/memory-engine/index.d.ts

@@ -1,4 +1,4 @@
-export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, memoryRecallDisciplineSegment, entryFileHeadCarriesOrigin, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, renderAnnouncements, type MemoryEngineOptions, type MemoryInjection, type EntryProvenanceAccount, } from "./engine.js";
+export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, memoryRecallDisciplineSegment, entryFileHeadCarriesOrigin, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, renderAnnouncements, type MemoryEngineOptions, type MemoryInjection, type EntryProvenanceAccount, memoryConsolidationRecommendedNotice, memoryConsolidationCommittedNotice, memoryConsolidationConflictNotice, memoryConsolidationRefusedNotice, type ConsolidationCommitReceipt, type ConsolidationReconcileReport, type ConsolidationResolveReceipt, type ConsolidationPlanSummary, } from "./engine.js";
 export { MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, type MemorySearchDetails, type MemorySearchHit, type CleanMemorySearchHit, type ExposedMemorySearchHit, type MemoryGetDetails, } from "./tools.js";
 export { MEMORY_EXPOSURE_BANNER, MEMORY_EXPOSURE_HANDLE_TAG, MEMORY_PROVENANCE_RECALL_SENTENCE, MEMORY_PROVENANCE_SEARCH_SENTENCE, memoryExposureIndexRow, parseMemoryExposureIndexRow, } from "./provenance-wording.js";
 export { scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE } from "./scan.js";
@@ -7,8 +7,10 @@ export { computeBundleSectionHashes, computeMemoryBundleHash, memoryBundleInvali
 export { ControlPlaneCorruptError, deriveControlPlaneDir, deriveRepoControlPlaneDir, deriveRepoKey, deriveRepoMemoryDir, deriveProjectMemoryDir, deriveProjectControlDir, recordProjectIdHint, lookupProjectIdHint, PROJECT_ID_HINTS_FILE, resolveMemoryEngineRoot, scopeDirFor, scopeDirName, claimRootScope, rootScopeOf, enqueueMemoryAnnouncement, drainMemoryAnnouncements, peekMemoryAnnouncements, bumpScanFuse, scanFuseCount, clearScanFuse, ANNOUNCEMENTS_FILE, MEMORY_ANNOUNCEMENTS_MAX, SCAN_FUSE_FILE, SCAN_FUSE_THRESHOLD, LINEAGE_FILE, CHALLENGES_FILE, CHALLENGED_HISTORY_FILE, CHALLENGE_LEDGER_MAX_EVENTS, rebuildStrictControlPlaneLedger, type ControlPlaneRebuildReceipt, type StrictControlPlaneLedger, type ChallengeAppendResult, type ChallengeAssignment, type ChallengeEvent, type ChallengedHistoryRow, type LineagePendingTxn, type LineagePromotion, } from "./layout.js";
 export { readV2HeaderHints, isInstructionEntry, type V2HeaderHints } from "./header-hints.js";
 export { parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, committedOriginOf, originEquals, ambiguousOriginRepresentation, type ParsedEntryFile } from "./frontmatter.js";
+export { committedDistilledOf, distilledEquals } from "./frontmatter.js";
+export { CONSOLIDATION_DEFAULTS, ConsolidationRefusedError, MEMORY_SEARCH_SUPERSEDED_TAG, consolidationTypeEligible, deriveSupersededSet, memorySupersededNote, readIntentCredentials, supersessionFuseCeiling, type ConsolidationGateRow, type ConsolidationIntent, type ConsolidationIntentCredentialRow, type ConsolidationLeaseSeat, type ConsolidationProductProposal, type ConsolidationProposal, type MemoryConsolidationOptions, } from "./consolidation.js";
 export { MEMORY_ORIGIN_CAUSES } from "./types.js";
-export type { MemoryBackend, MemoryEntry, MemoryEntryFrontmatter, MemoryEntryOrigin, MemoryOriginCause, MemoryEntryHeader, ScoredMemoryEntry, NotePatch, PatchReport, MaterializedFile, MemorySessionHandle, HarvestReport, HarvestRejection, HarvestRejectionCode, MemoryAnnouncement, ScanFinding, } from "./types.js";
+export type { MemoryBackend, MemoryEntry, MemoryEntryFrontmatter, MemoryEntryOrigin, MemoryOriginCause, MemoryEntryDistilled, MemoryEntryDistilledInput, MemoryEntryHeader, ScoredMemoryEntry, NotePatch, PatchReport, MaterializedFile, MemorySessionHandle, HarvestReport, HarvestRejection, HarvestRejectionCode, MemoryAnnouncement, ScanFinding, } from "./types.js";
 export { memoryBackendContract, assertMemoryBackendSearchEquivalence, type MemoryBackendContractHooks, } from "./memory-backend-contract.js";
 export { SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, type ParsedScopeKey, } from "./scope-contract.js";
 export { migrateScope, type MigrateScopeReport } from "./migrate.js";

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

@@ -1,4 +1,4 @@
-export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, memoryRecallDisciplineSegment, entryFileHeadCarriesOrigin, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, renderAnnouncements, } from "./engine.js";
+export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, memoryRecallDisciplineSegment, entryFileHeadCarriesOrigin, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, renderAnnouncements, memoryConsolidationRecommendedNotice, memoryConsolidationCommittedNotice, memoryConsolidationConflictNotice, memoryConsolidationRefusedNotice, } from "./engine.js";
 export { MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, } from "./tools.js";
 export { MEMORY_EXPOSURE_BANNER, MEMORY_EXPOSURE_HANDLE_TAG, MEMORY_PROVENANCE_RECALL_SENTENCE, MEMORY_PROVENANCE_SEARCH_SENTENCE, memoryExposureIndexRow, parseMemoryExposureIndexRow, } from "./provenance-wording.js";
 export { scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE } from "./scan.js";
@@ -7,6 +7,8 @@ export { computeBundleSectionHashes, computeMemoryBundleHash, memoryBundleInvali
 export { ControlPlaneCorruptError, deriveControlPlaneDir, deriveRepoControlPlaneDir, deriveRepoKey, deriveRepoMemoryDir, deriveProjectMemoryDir, deriveProjectControlDir, recordProjectIdHint, lookupProjectIdHint, PROJECT_ID_HINTS_FILE, resolveMemoryEngineRoot, scopeDirFor, scopeDirName, claimRootScope, rootScopeOf, enqueueMemoryAnnouncement, drainMemoryAnnouncements, peekMemoryAnnouncements, bumpScanFuse, scanFuseCount, clearScanFuse, ANNOUNCEMENTS_FILE, MEMORY_ANNOUNCEMENTS_MAX, SCAN_FUSE_FILE, SCAN_FUSE_THRESHOLD, LINEAGE_FILE, CHALLENGES_FILE, CHALLENGED_HISTORY_FILE, CHALLENGE_LEDGER_MAX_EVENTS, rebuildStrictControlPlaneLedger, } from "./layout.js";
 export { readV2HeaderHints, isInstructionEntry } from "./header-hints.js";
 export { parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, committedOriginOf, originEquals, ambiguousOriginRepresentation } from "./frontmatter.js";
+export { committedDistilledOf, distilledEquals } from "./frontmatter.js";
+export { CONSOLIDATION_DEFAULTS, ConsolidationRefusedError, MEMORY_SEARCH_SUPERSEDED_TAG, consolidationTypeEligible, deriveSupersededSet, memorySupersededNote, readIntentCredentials, supersessionFuseCeiling, } from "./consolidation.js";
 export { MEMORY_ORIGIN_CAUSES } from "./types.js";
 export { memoryBackendContract, assertMemoryBackendSearchEquivalence, } from "./memory-backend-contract.js";
 export { SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, } from "./scope-contract.js";

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

@@ -513,6 +513,137 @@ export async function memoryBackendContract(hooks) {
         assert.deepStrictEqual((await b.getByIds([m0.id]))[0]?.frontmatter.origin, origin);
         assert.strictEqual((await b.getByIds([p0.id]))[0]?.frontmatter.trust, "untrusted");
     });
+    const distilledEntry = (id, scope, slug, body, inputs) => {
+        const e = { id, scope, slug, frontmatter: { name: slug, distilled: { planId: "plan-c35-0001", at: 1_700_000_000_000, carrierRev: "", inputs } }, body, rev: "" };
+        e.rev = computeEntryRev(e);
+        e.frontmatter.distilled.carrierRev = e.rev;
+        return e;
+    };
+    defer("design/339 c35: distilled round-trips deep-equal (typed block, superseded rows); rev is conditional — no-block entries keep their historical rev, carrierRev never participates", async () => {
+        const b = await hooks.make();
+        const inputs = [
+            { id: "id-input-0001", rev: "aaaaaaaaaaaaaaaa", superseded: true },
+            { id: "id-input-0002", rev: "bbbbbbbbbbbbbbbb" },
+        ];
+        const p = distilledEntry("id-prod-00001", "s1", "product", "the distilled abstraction", inputs);
+        const rep = await b.applyPatches([{ op: "add", id: p.id, entry: p, guard: "absent" }]);
+        assert.deepStrictEqual(rep.conflicts, []);
+        const [got] = await b.getByIds([p.id]);
+        assert.deepStrictEqual(got?.frontmatter.distilled, p.frontmatter.distilled, "the distilled block must round-trip deep-equal through storage");
+        const bare = { id: p.id, scope: p.scope, slug: p.slug, frontmatter: { name: p.frontmatter.name }, body: p.body, rev: "" };
+        bare.rev = computeEntryRev(bare);
+        assert.notStrictEqual(bare.rev, p.rev, "the distilled block participates in the rev");
+        const otherAnchor = { ...p, frontmatter: { ...p.frontmatter, distilled: { ...p.frontmatter.distilled, carrierRev: "different-anchor" } } };
+        assert.strictEqual(computeEntryRev(otherAnchor), p.rev, "carrierRev is outside the rev tuple");
+        const plainRow = entry("id-plain-0001", "s1", "plain", "plain body", { name: "Plain" });
+        await b.applyPatches([{ op: "add", id: plainRow.id, entry: plainRow }]);
+        assert.strictEqual((await b.getByIds([plainRow.id]))[0]?.rev, plainRow.rev);
+    });
+    defer("design/339 c36: distilled immutability across update strip/member rewrite, plain re-add, guard add and same-batch delete+re-add ⇒ /malformed patch refused/; committed tombstone is the legal exit", async () => {
+        const b = await hooks.make();
+        const p = distilledEntry("id-prod-00002", "s1", "prod-immutable", "product body", [{ id: "id-input-0003", rev: "cccccccccccccccc", superseded: true }]);
+        await b.applyPatches([{ op: "add", id: p.id, entry: p, guard: "absent" }]);
+        const expectMalformed = async (patch) => {
+            const rep = await b.applyPatches([patch]);
+            assert.strictEqual(rep.applied.filter((a) => a.id === p.id && a.op !== "delete").length, 0, "the touching op must not apply");
+            const bad = rep.conflicts.find((c) => c.id === p.id);
+            assert.match(bad?.reason ?? "", /malformed patch refused/);
+            const [committed] = await b.getByIds([p.id]);
+            assert.deepStrictEqual(committed?.frontmatter.distilled, p.frontmatter.distilled, "the committed block survives the refused op");
+        };
+        const stripped = { ...p, frontmatter: { name: p.frontmatter.name }, body: "edited" };
+        stripped.rev = computeEntryRev(stripped);
+        await expectMalformed({ op: "update", id: p.id, entry: stripped, baseRev: p.rev });
+        const flipped = { ...p, frontmatter: { ...p.frontmatter, distilled: { ...p.frontmatter.distilled, inputs: [{ id: "id-input-0003", rev: "cccccccccccccccc" }] } } };
+        flipped.rev = computeEntryRev(flipped);
+        await expectMalformed({ op: "update", id: p.id, entry: flipped, baseRev: p.rev });
+        const reanchored = { ...p, frontmatter: { ...p.frontmatter, distilled: { ...p.frontmatter.distilled, carrierRev: "forged-anchor-0001" } } };
+        reanchored.rev = computeEntryRev(reanchored);
+        assert.strictEqual(reanchored.rev, p.rev, "precondition: the carrierRev rewrite moves no rev");
+        await expectMalformed({ op: "update", id: p.id, entry: reanchored, baseRev: p.rev });
+        const bareAdd = { id: p.id, scope: p.scope, slug: p.slug, frontmatter: { name: p.frontmatter.name }, body: p.body, rev: "" };
+        bareAdd.rev = computeEntryRev(bareAdd);
+        await expectMalformed({ op: "add", id: p.id, entry: bareAdd });
+        await expectMalformed({ op: "add", id: p.id, entry: bareAdd, guard: "absent" });
+        const rep = await b.applyPatches([
+            { op: "delete", id: p.id, baseRev: p.rev },
+            { op: "add", id: p.id, entry: bareAdd },
+        ]);
+        assert.match(rep.conflicts.find((c) => c.op === "add")?.reason ?? "", /malformed patch refused/);
+        const rep2 = await b.applyPatches([{ op: "add", id: p.id, entry: bareAdd }]);
+        assert.deepStrictEqual(rep2.conflicts, []);
+        assert.strictEqual((await b.getByIds([p.id]))[0]?.frontmatter.distilled, undefined);
+    });
+    defer("design/339 c37: PRECEDENCE — a distilled strip riding a STALE baseRev still answers the malformed refusal, never the rev-mismatch conflict", async () => {
+        const b = await hooks.make();
+        const p = distilledEntry("id-prod-00003", "s1", "prod-precedence", "v1", [{ id: "id-input-0004", rev: "dddddddddddddddd", superseded: true }]);
+        await b.applyPatches([{ op: "add", id: p.id, entry: p, guard: "absent" }]);
+        const v2 = { ...p, body: "v2", frontmatter: { ...p.frontmatter, distilled: { ...p.frontmatter.distilled } } };
+        v2.rev = computeEntryRev(v2);
+        const repOk = await b.applyPatches([{ op: "update", id: p.id, entry: v2, baseRev: p.rev }]);
+        assert.deepStrictEqual(repOk.conflicts, []);
+        const stripped = { id: p.id, scope: p.scope, slug: p.slug, frontmatter: { name: p.frontmatter.name }, body: "v3", rev: "" };
+        stripped.rev = computeEntryRev(stripped);
+        const rep = await b.applyPatches([{ op: "update", id: p.id, entry: stripped, baseRev: p.rev }]);
+        assert.strictEqual(rep.applied.length, 0);
+        assert.match(rep.conflicts[0]?.reason ?? "", /malformed patch refused/);
+        assert.doesNotMatch(rep.conflicts[0]?.reason ?? "", /rev mismatch/);
+    });
+    defer("design/339 c38: the distilled fact rides BOTH header faces (listHeaders + search) as carrierRev + the superseded-row projection; block-free entries carry none on either face", async () => {
+        const b = await hooks.make();
+        const p = distilledEntry("id-prod-00004", "s1", "prod-header", "searchable distilled kumquat", [
+            { id: "id-input-0005", rev: "eeeeeeeeeeeeeeee", superseded: true },
+            { id: "id-input-0006", rev: "ffffffffffffffff" },
+        ]);
+        const plain = entry("id-plain-0001", "s1", "plain", "searchable plain kumquat");
+        await b.applyPatches([
+            { op: "add", id: p.id, entry: p, guard: "absent" },
+            { op: "add", id: plain.id, entry: plain },
+        ]);
+        const headers = await b.listHeaders(["s1"]);
+        const ph = headers.find((h) => h.id === p.id);
+        assert.deepStrictEqual(ph?.distilled, { carrierRev: p.rev, supersedes: [{ id: "id-input-0005", rev: "eeeeeeeeeeeeeeee" }] });
+        assert.strictEqual(headers.find((h) => h.id === plain.id)?.distilled, undefined);
+        const hits = await b.search("kumquat", ["s1"], { limit: 10 });
+        const psh = hits.find((h) => h.id === p.id);
+        assert.deepStrictEqual(psh?.distilled, { carrierRev: p.rev, supersedes: [{ id: "id-input-0005", rev: "eeeeeeeeeeeeeeee" }] }, "search reports the same committed fact");
+        assert.strictEqual(hits.find((h) => h.id === plain.id)?.distilled, undefined);
+    });
+    defer("design/339 c39: the plan-replay add spelling — a guard-absent re-add of the identical product is idempotent (one row, no overwrite, no conflict); a different-rev occupant answers add_guard_absent_conflict with currentRev", async () => {
+        const b = await hooks.make();
+        const p = distilledEntry("id-prod-00005", "s1", "prod-replay", "replayed product", [{ id: "id-input-0007", rev: "abababababababab", superseded: true }]);
+        await b.applyPatches([{ op: "add", id: p.id, entry: p, guard: "absent" }]);
+        const replay = await b.applyPatches([{ op: "add", id: p.id, entry: p, guard: "absent" }]);
+        assert.deepStrictEqual(replay.conflicts, [], "the identical replay is a no-op apply, never a conflict");
+        const rows = await b.getByIds([p.id]);
+        assert.strictEqual(rows.length, 1, "one row — a replay must not mint a duplicate");
+        assert.strictEqual(rows[0]?.rev, p.rev);
+        assert.strictEqual((await b.listHeaders(["s1"])).filter((h) => h.id === p.id).length, 1, "one projection");
+        const foreign = { ...p, body: "foreign occupant", frontmatter: { ...p.frontmatter, distilled: { ...p.frontmatter.distilled } } };
+        foreign.rev = computeEntryRev(foreign);
+        await b.applyPatches([{ op: "update", id: p.id, entry: foreign, baseRev: p.rev }]);
+        const conflicted = await b.applyPatches([{ op: "add", id: p.id, entry: p, guard: "absent" }]);
+        assert.strictEqual(conflicted.applied.length, 0);
+        assert.match(conflicted.conflicts[0]?.reason ?? "", /add_guard_absent_conflict/);
+        assert.strictEqual(conflicted.conflicts[0]?.currentRev, foreign.rev);
+        assert.strictEqual((await b.getByIds([p.id]))[0]?.body.replace(/\s+$/, ""), "foreign occupant", "the occupant survives");
+    });
+    defer("design/339 c40: the directed-arm judgment face — after an update-replay conflict, the reported currentRev and the committed read both answer the planned post-state's rev (already-applied is judgeable), and the judgment read is side-effect-free", async () => {
+        const b = await hooks.make();
+        const v1 = entry("id-directed-01", "s1", "directed", "v1");
+        await b.applyPatches([{ op: "add", id: v1.id, entry: v1 }]);
+        const terminal = entry("id-directed-01", "s1", "directed", "the intended terminal state");
+        const plannedPostRev = terminal.rev;
+        const first = await b.applyPatches([{ op: "update", id: v1.id, entry: terminal, baseRev: v1.rev }]);
+        assert.deepStrictEqual(first.conflicts, []);
+        const replay = await b.applyPatches([{ op: "update", id: v1.id, entry: terminal, baseRev: v1.rev }]);
+        assert.strictEqual(replay.applied.length, 0);
+        assert.strictEqual(replay.conflicts[0]?.currentRev, plannedPostRev, "the conflict's currentRev answers the already-applied judgment");
+        const read1 = await b.getByIds([v1.id]);
+        const read2 = await b.getByIds([v1.id]);
+        assert.strictEqual(read1[0]?.rev, plannedPostRev);
+        assert.strictEqual(read2[0]?.rev, plannedPostRev, "the judgment read advances no rev");
+    });
     defer("consolidation cursor round-trips per scope; unset → undefined", async () => {
         const b = await hooks.make();
         assert.strictEqual(await b.getConsolidationCursor("s1"), undefined);

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

@@ -89,6 +89,18 @@ function parseMemorySyncResponse(raw, scope, peer) {
                 (originWire["cause"] !== undefined && !(typeof originWire["cause"] === "string" && MEMORY_ORIGIN_CAUSES.includes(originWire["cause"]))))) {
             fail('entry.frontmatter.origin must be { taint: "external", cause?, at } with a known cause when present');
         }
+        const distilledWire = fm["distilled"];
+        if (distilledWire !== undefined &&
+            (!isRecord(distilledWire) ||
+                !isNonEmptyString(distilledWire["planId"]) ||
+                typeof distilledWire["at"] !== "number" ||
+                !Number.isFinite(distilledWire["at"]) ||
+                !isNonEmptyString(distilledWire["carrierRev"]) ||
+                !(Array.isArray(distilledWire["inputs"]) &&
+                    distilledWire["inputs"].length > 0 &&
+                    distilledWire["inputs"].every((row) => isRecord(row) && isNonEmptyString(row["id"]) && isNonEmptyString(row["rev"]) && (row["superseded"] === undefined || row["superseded"] === true))))) {
+            fail("entry.frontmatter.distilled must be { planId, at, carrierRev, inputs: [{ id, rev, superseded? }, …] } when present");
+        }
         const extraRaw = fm["extra"];
         if (Array.isArray(extraRaw) && extraRaw.every((s) => typeof s === "string")) {
             const pickedOrigin = originWire !== undefined
@@ -133,6 +145,20 @@ function parseMemorySyncResponse(raw, scope, peer) {
                         },
                     }
                     : {}),
+                ...(distilledWire !== undefined
+                    ? {
+                        distilled: {
+                            planId: distilledWire["planId"],
+                            at: distilledWire["at"],
+                            carrierRev: distilledWire["carrierRev"],
+                            inputs: distilledWire["inputs"].map((row) => ({
+                                id: row["id"],
+                                rev: row["rev"],
+                                ...(row["superseded"] === true ? { superseded: true } : {}),
+                            })),
+                        },
+                    }
+                    : {}),
                 ...(fm["extra"] !== undefined ? { extra: [...fm["extra"]] } : {}),
             },
         });

package/dist/core/memory-engine/tools.d.ts

@@ -121,6 +121,9 @@ export interface CleanMemorySearchHit {
     mtimeMs: number;
     sizeBytes: number;
     exposure?: never;
+    /** design/339 §3.4 — present ⇔ this hit is SUPERSEDED (retrieved via `includeSuperseded`; the
+     *  default face filters such hits out) — the value is the standing carrier entry's id. */
+    supersededBy?: string;
 }
 /**
  * design/336 §5.2 — a MARKED hit is an OPAQUE HANDLE: id/scope/score/age/size plus the exposure
@@ -140,6 +143,8 @@ export interface ExposedMemorySearchHit {
     slug?: never;
     name?: never;
     description?: never;
+    /** design/339 §3.4 — see {@link CleanMemorySearchHit.supersededBy} (same seat on the handle shape). */
+    supersededBy?: string;
 }
 /**
  * The search hit union (design/336 B5 — a DISCRIMINATED union on `exposure`, deliberately not an
@@ -181,6 +186,10 @@ export interface MemoryGetDetails {
     /** design/336 §5.3 — present on an `ok` delivery of a MARKED entry under `provenance: "carry"`
      *  (the structured half of the banner). Absent under "off" and for unmarked entries. */
     exposure?: "external";
+    /** design/339 §3.4 — present on an `ok` delivery of a SUPERSEDED entry (mode-free, data-driven):
+     *  the standing carrier entry's id (the disclosure note's structured half). Delivery proceeds —
+     *  supersession is disclosure/ordering, never withholding. */
+    supersededBy?: string;
 }
 /** Cut `text` to at most `maxBytes` UTF-8 bytes on a CODE POINT boundary (a byte-wise slice would
  *  strand half a character), reporting how many bytes were dropped. Unchanged text reports 0.