@sema-agent/core 5.21.1 → 5.23.0

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

@@ -6,7 +6,7 @@ import { inlineUntrusted } from "../untrusted-text.js";
 import { formatMemoryAge } from "../memory-recall.js";
 import { computeEntryRev, parseEntryFile, serializeEntryFile } from "./frontmatter.js";
 import { DEFAULT_MAX_ENTRY_DEPTH, MEMORY_INDEX_FILENAME, scanEntryFiles } from "./file-backend.js";
-import { QUARANTINE_DIR, SCAN_FUSE_THRESHOLD, quarantineAndTombstone, readIndexRevs, writeIndexRevs, bumpScanFuse, canonicalize, claimRootScope, clearScanFuse, adoptCanonicalKeyedControlDir, deriveControlPlaneDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, ensureDirExists, isContainedIn, markSessionPolluted, readSessionPollution, recordRetrievedAccount, writeFileNoFollow, readRetrievedAccount, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirFor, } from "./layout.js";
+import { QUARANTINE_DIR, SCAN_FUSE_THRESHOLD, quarantineAndTombstone, readIndexRevs, writeIndexRevs, bumpScanFuse, canonicalize, claimRootScope, clearScanFuse, adoptCanonicalKeyedControlDir, deriveControlPlaneDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, ensureDirExists, isContainedIn, markSessionPolluted, readSessionPollution, recordRetrievedAccount, writeFileNoFollow, readRetrievedAccount, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirFor, appendChallengeEvents, appendLineageAudit, rebuildStrictControlPlaneLedger, isStrictControlPlaneLedgerCorrupt, CHALLENGE_LEDGER_MAX_EVENTS, adjudicateLineagePending, challengedEntryIds, clearLineageForEntries, discardLineagePending, lineageContributionsOfSession, lineageLatchedIds, promoteLineagePending, readChallengeEvents, readChallengedHistory, readLineageRecord, recordChallengedHistory, recordLineageCredential, reconcileLineage, resolveChallengeEvent, stageLineagePending, } from "./layout.js";
 import { scanMemoryFileName, scanMemoryWrite, scanRemediation } from "./scan.js";
 export const MEMORY_INSTRUCTION_TEMPLATE = `# Memory
 
@@ -33,6 +33,7 @@ export function buildMemoryInstruction(memoryDir, instructionFileName) {
     return MEMORY_INSTRUCTION_TEMPLATE.replaceAll("{{MEMORY_DIR}}", dir).replaceAll("{{INSTRUCTION_FILE}}", instructionFileName ?? "CLAUDE.md");
 }
 export const MEMORY_RECALL_DISCIPLINE = "Before answering questions about earlier work, decisions, dates, people, or the user's preferences, look them up: `memory_search` finds entries by keyword and `memory_get` reads a full entry — the injected memory index only lists what exists. When a lookup comes up empty, say that you checked memory and found nothing instead of guessing.";
+export const MEMORY_PREFERENCE_DISCIPLINE = "When the user confirms a stored preference or fact still holds, refresh that entry's `last-confirmed: <YYYY-MM-DD>` frontmatter line (add it when absent). When you save a preference, add an `applies-when: <context>` frontmatter line naming when it applies. Both are plain frontmatter lines — write them yourself; nothing fills them in for you.";
 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]";
@@ -87,6 +88,8 @@ export class MemoryEngine {
         }
     }
     recordRetrieved(ids) {
+        for (const id of ids)
+            this.retrievedThisSession.add(id);
         try {
             recordRetrievedAccount(this.controlDir, ids, this.now);
         }
@@ -124,6 +127,28 @@ export class MemoryEngine {
                 }
             }
         }
+        try {
+            const rec = this.sessionPollution(sessionId) ?? { at: this.now(), reason };
+            const contributions = lineageContributionsOfSession(this.controlDir, sessionId);
+            this.challengeAndAnnounce(contributions.map((c) => ({
+                eventId: `pollution:${sessionId}:${rec.at}:${c.entryId}`,
+                entryId: c.entryId,
+                reason: `challenged: the contributing session was marked polluted`,
+                challengedRev: c.lastRev,
+            })));
+        }
+        catch (err) {
+            const sink = this.onIncident;
+            if (sink !== undefined) {
+                try {
+                    const e = new Error(`memory challenge sweep for a polluted session failed: ${err instanceof Error ? err.message : String(err)}`);
+                    e.code = "memory.challenge_sweep_failed";
+                    sink(e);
+                }
+                catch {
+                }
+            }
+        }
     }
     sessionPollution(sessionId) {
         const inProcess = this.pollutedSessions.get(sessionId);
@@ -136,6 +161,162 @@ export class MemoryEngine {
             return undefined;
         }
     }
+    retrievedThisSession = new Set();
+    readChallengeExclusions() {
+        const out = new Map();
+        for (const id of lineageLatchedIds(this.controlDir))
+            out.set(id, { code: "lineage_pending" });
+        for (const [id, g] of challengedEntryIds(this.controlDir))
+            out.set(id, { code: "challenged", generation: g.generation, at: g.at });
+        return out;
+    }
+    challengeAndAnnounce(events) {
+        if (events.length === 0)
+            return [];
+        const { assignments: assigned, eventCount } = appendChallengeEvents(this.controlDir, events, this.now);
+        if (eventCount !== undefined)
+            this.discloseChallengeLedgerSize(eventCount);
+        const fresh = assigned.filter((a) => !a.replayed);
+        if (fresh.length > 0) {
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, {
+                    kind: "gate",
+                    at: this.now(),
+                    items: fresh.map((a) => `memory entry challenged: id ${quoteId(a.entryId)} (generation ${a.generation}) — its content is withheld from memory tools and the injected index. If the fact is still needed, verify it with the user, record a fresh entry from their current statement, and tombstone the old one.`),
+                });
+            }
+            catch (err) {
+                this.discloseAnnounceFailure("challenge enqueue", err);
+            }
+        }
+        return assigned;
+    }
+    challengeLedgerSizeDisclosed = false;
+    discloseChallengeLedgerSize(eventCount) {
+        if (this.challengeLedgerSizeDisclosed || eventCount <= CHALLENGE_LEDGER_MAX_EVENTS)
+            return;
+        this.challengeLedgerSizeDisclosed = true;
+        const sink = this.onIncident;
+        if (sink === undefined)
+            return;
+        try {
+            const err = new Error(`memory challenge ledger holds ${eventCount} events, past the calibrated bound of ${CHALLENGE_LEDGER_MAX_EVENTS}: ` +
+                `the whole file is rewritten on every challenge and parsed on every model-visible read (index rebuild, memory tools), ` +
+                `so this account now costs the session latency. It is NOT rotated — dropping events would un-withhold their entries — ` +
+                `so the deployment resolves the settled generations or archives the account deliberately.`);
+            err.code = "memory.challenge_ledger_oversize";
+            sink(err);
+        }
+        catch {
+        }
+    }
+    rebuildCorruptControlPlaneLedger(ledger, reason) {
+        if (typeof reason !== "string" || reason.trim() === "") {
+            const e = new Error("rebuildCorruptControlPlaneLedger: a non-empty reason is required (this call drops taint evidence — it is recorded, never implicit)");
+            e.code = "config.memory_rebuild_reason";
+            throw e;
+        }
+        if (!isStrictControlPlaneLedgerCorrupt(this.controlDir, ledger)) {
+            const e = new Error(`${ledger === "challenges" ? "memory challenge ledger" : "memory lineage ledger"} reads cleanly — refusing to rebuild it. This call exists to recover a ledger whose corruption already refuses every read; resetting a healthy one would drop taint evidence that is still doing its job.`);
+            e.code = "memory.control_plane_not_corrupt";
+            throw e;
+        }
+        enqueueMemoryAnnouncement(this.controlDir, {
+            kind: "gate",
+            at: this.now(),
+            items: [
+                ledger === "challenges"
+                    ? `memory control plane: the challenge ledger was found CORRUPT and a deployment-initiated reset to empty was requested — entries that were withheld by an unresolved challenge may no longer be withheld. Treat facts recalled from memory as unverified until confirmed with the user.`
+                    : `memory control plane: the harvest lineage ledger was found CORRUPT and a deployment-initiated reset to empty was requested — which session contributed which entry may no longer be recorded for anything written before this point.`,
+            ],
+        });
+        const receipt = rebuildStrictControlPlaneLedger(this.controlDir, ledger, this.now);
+        const sink = this.onIncident;
+        if (sink !== undefined) {
+            try {
+                const err = new Error(`memory control plane: ${ledger} ledger rebuilt after corruption (reason: ${reason}). ` +
+                    `The corrupt bytes are quarantined at ${receipt.quarantinedTo.join(", ") || "(no file existed)"} — ` +
+                    `they are the only remaining record of what this account held.`);
+                err.code = "memory.control_plane_rebuilt";
+                sink(err);
+            }
+            catch {
+            }
+        }
+        return receipt;
+    }
+    challengeEntries(ids, reason, requestId) {
+        if (typeof requestId !== "string" || requestId === "") {
+            const e = new Error("challengeEntries: requestId is required (idempotency identity — retries must reuse it; the engine does not mint one)");
+            e.code = "config.memory_challenge_request";
+            throw e;
+        }
+        return this.challengeAndAnnounce(ids.map((entryId) => ({ eventId: `${requestId}:${entryId}`, entryId, reason })));
+    }
+    challengeSession(sessionId, reason, requestId) {
+        if (typeof requestId !== "string" || requestId === "") {
+            const e = new Error("challengeSession: requestId is required (idempotency identity — retries must reuse it; the engine does not mint one)");
+            e.code = "config.memory_challenge_request";
+            throw e;
+        }
+        const contributions = lineageContributionsOfSession(this.controlDir, sessionId);
+        return this.challengeAndAnnounce(contributions.map((c) => ({ eventId: `${requestId}:${c.entryId}`, entryId: c.entryId, reason, challengedRev: c.lastRev })));
+    }
+    resolveChallenge(entryId, generation, reason, requestId) {
+        const { resolved, eventCount } = resolveChallengeEvent(this.controlDir, entryId, generation, reason, this.now, requestId);
+        if (eventCount !== undefined)
+            this.discloseChallengeLedgerSize(eventCount);
+        return resolved;
+    }
+    adjudicatePendingLineage(txnId, action) {
+        const promoted = adjudicateLineagePending(this.controlDir, txnId, action, this.now);
+        this.settlePromotions(promoted);
+        return promoted;
+    }
+    listPendingLineage() {
+        return readLineageRecord(this.controlDir).pending;
+    }
+    readChallengeLedger() {
+        return readChallengeEvents(this.controlDir);
+    }
+    readChallengedHistoryAccount() {
+        try {
+            return readChallengedHistory(this.controlDir);
+        }
+        catch {
+            return {};
+        }
+    }
+    settlePromotions(promoted) {
+        if (promoted.length === 0)
+            return;
+        const events = [];
+        for (const p of promoted) {
+            let rec;
+            try {
+                rec = readSessionPollution(this.controlDir, p.sessionId);
+            }
+            catch {
+                rec = undefined;
+            }
+            if (rec === undefined)
+                rec = this.pollutedSessions.get(p.sessionId);
+            if (rec === undefined)
+                continue;
+            events.push({
+                eventId: `pollution:${p.sessionId}:${rec.at}:${p.entryId}`,
+                entryId: p.entryId,
+                reason: `challenged: the contributing session was marked polluted`,
+                challengedRev: p.rev,
+            });
+        }
+        this.challengeAndAnnounce(events);
+        try {
+            appendLineageAudit(this.controlDir, promoted.map((p) => ({ entryId: p.entryId, sessionId: p.sessionId, rev: p.rev, at: this.now() })));
+        }
+        catch {
+        }
+    }
     async materialize(scopes, writeScope) {
         ensureDirExists(this.memoryDir);
         ensureDirExists(this.controlDir);
@@ -316,7 +497,8 @@ export class MemoryEngine {
         return report;
     }
     async harvestCore(handle, opts) {
-        const pollutedReason = opts?.polluted?.reason;
+        let pollutedReason = opts?.polluted?.reason ?? (opts?.sessionId !== undefined ? this.sessionPollution(opts.sessionId)?.reason : undefined);
+        const lineageSessionId = opts?.sessionId;
         const startedAt = this.now();
         const report = {
             ok: true,
@@ -344,6 +526,30 @@ export class MemoryEngine {
             report.incident = { kind: "sidecar_corrupt", detail: `memory control plane refused: ${err instanceof Error ? err.message : String(err)}` };
             return report;
         }
+        try {
+            const rec = reconcileLineage(this.controlDir, this.now);
+            this.settlePromotions(rec.promoted);
+            for (const u of rec.undecidable) {
+                report.warnings.push(`memory lineage transaction ${u.txnId} is unsettled (a crash landed between commit and its durable credential) — ${u.entryIds.length} entr${u.entryIds.length === 1 ? "y is" : "ies are"} latched (memory reads refuse them) until the host adjudicates it (adjudicatePendingLineage)`);
+            }
+            if (pollutedReason !== undefined && lineageSessionId !== undefined) {
+                const rec2 = this.sessionPollution(lineageSessionId);
+                if (rec2 !== undefined) {
+                    const contributions = lineageContributionsOfSession(this.controlDir, lineageSessionId);
+                    this.challengeAndAnnounce(contributions.map((c) => ({
+                        eventId: `pollution:${lineageSessionId}:${rec2.at}:${c.entryId}`,
+                        entryId: c.entryId,
+                        reason: `challenged: the contributing session was marked polluted`,
+                        challengedRev: c.lastRev,
+                    })));
+                }
+            }
+        }
+        catch (err) {
+            report.ok = false;
+            report.incident = { kind: "sidecar_corrupt", detail: `memory lineage/challenge ledger refused: ${err instanceof Error ? err.message : String(err)}` };
+            return report;
+        }
         if (!existsSync(handle.writableRoot)) {
             report.ok = false;
             report.incident = { kind: "dir_missing", detail: `memory writable root is gone: ${handle.writableRoot}` };
@@ -693,13 +899,99 @@ export class MemoryEngine {
             patchReport = { applied: [], conflicts: [] };
         }
         else {
-            try {
-                patchReport = await this.backend.applyPatches(patches);
+            const txnId = uuidv7();
+            const pendingRows = patches.filter((p) => p.op !== "delete" && p.entry !== undefined).map((p) => ({ entryId: p.id, rev: p.entry.rev }));
+            const lineageArmed = lineageSessionId !== undefined && pendingRows.length > 0;
+            if (lineageArmed) {
+                try {
+                    stageLineagePending(this.controlDir, txnId, lineageSessionId, pendingRows, this.now);
+                }
+                catch (err) {
+                    report.ok = false;
+                    report.incident = { kind: "sidecar_corrupt", detail: `memory lineage write-ahead refused: ${err instanceof Error ? err.message : String(err)}` };
+                    return report;
+                }
             }
-            catch (err) {
-                report.ok = false;
-                report.incident = { kind: "sidecar_corrupt", detail: `memory commit refused: ${err instanceof Error ? err.message : String(err)}` };
-                return report;
+            const preCommit = lineageSessionId !== undefined ? this.sessionPollution(lineageSessionId) : undefined;
+            if (preCommit !== undefined) {
+                if (lineageArmed) {
+                    try {
+                        discardLineagePending(this.controlDir, txnId);
+                    }
+                    catch {
+                    }
+                }
+                pollutedReason = preCommit.reason;
+                for (const f of records)
+                    await containPollutedRecord(f);
+                patchReport = { applied: [], conflicts: [] };
+            }
+            else {
+                try {
+                    patchReport = await this.backend.applyPatches(patches);
+                }
+                catch (err) {
+                    if (lineageArmed) {
+                        try {
+                            discardLineagePending(this.controlDir, txnId);
+                        }
+                        catch {
+                        }
+                    }
+                    report.ok = false;
+                    report.incident = { kind: "sidecar_corrupt", detail: `memory commit refused: ${err instanceof Error ? err.message : String(err)}` };
+                    return report;
+                }
+                if (lineageArmed) {
+                    try {
+                        recordLineageCredential(this.controlDir, txnId, patchReport.applied.filter((a) => a.op !== "delete").map((a) => a.id), this.now);
+                        const promoted = promoteLineagePending(this.controlDir, txnId, this.now);
+                        this.settlePromotions(promoted);
+                    }
+                    catch (err) {
+                        const detail = `memory lineage settlement failed after commit — the affected entries stay latched (memory reads refuse them) until a later harvest reconciles or the host adjudicates: ${err instanceof Error ? err.message : String(err)}`;
+                        report.warnings.push(detail);
+                        const sink = this.onIncident;
+                        if (sink !== undefined) {
+                            try {
+                                const e = new Error(detail);
+                                e.code = "memory.lineage_settle_failed";
+                                sink(e);
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                }
+                const deletedIds = patchReport.applied.filter((a) => a.op === "delete").map((a) => a.id);
+                if (deletedIds.length > 0) {
+                    try {
+                        clearLineageForEntries(this.controlDir, deletedIds);
+                    }
+                    catch {
+                    }
+                }
+                try {
+                    recordChallengedHistory(this.controlDir, patchReport.applied
+                        .filter((a) => (a.op === "update" || a.op === "delete") && this.retrievedThisSession.has(a.id))
+                        .map((a) => ({ entryId: a.id, op: a.op === "delete" ? "tombstone" : "update" })), this.now);
+                }
+                catch {
+                }
+                const postCommit = lineageSessionId !== undefined ? this.sessionPollution(lineageSessionId) : undefined;
+                if (postCommit !== undefined) {
+                    const appliedNonDelete = patchReport.applied.filter((a) => a.op !== "delete").map((a) => a.id);
+                    try {
+                        this.challengeAndAnnounce(appliedNonDelete.map((id) => ({
+                            eventId: `pollution:${lineageSessionId}:${postCommit.at}:${id}`,
+                            entryId: id,
+                            reason: `challenged: the contributing session was marked polluted`,
+                        })));
+                    }
+                    catch (err) {
+                        report.warnings.push(`memory challenge of this harvest's commits failed (session polluted post-commit): ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
             }
         }
         const appliedIds = new Set(patchReport.applied.filter((a) => a.op !== "delete").map((a) => a.id));
@@ -798,18 +1090,39 @@ export class MemoryEngine {
     }
     rebuildIndex(handle, headers, opts, warnings) {
         const indexPath = join(handle.writableRoot, MEMORY_INDEX_FILENAME);
+        let excludedIds;
+        try {
+            excludedIds = this.readChallengeExclusions();
+        }
+        catch (err) {
+            const detail = `memory index withheld: the challenge/lineage ledger cannot be trusted (${err instanceof Error ? err.message : String(err)}) — fail-closed, nothing injected`;
+            warnings?.push(detail);
+            handle.indexOnDiskUntrusted = true;
+            const sink = this.onIncident;
+            if (sink !== undefined) {
+                try {
+                    const e = new Error(detail);
+                    e.code = "memory.challenge_ledger_corrupt";
+                    sink(e);
+                }
+                catch {
+                }
+            }
+            return "";
+        }
         const existing = opts.ignoreOnDisk === true ? "" : (readNoFollowSafe(indexPath) ?? "");
         const indexRevs = readIndexRevs(this.controlDir);
         const nextIndexRevs = {};
         const expected = new Map();
+        const excludedTargets = new Set();
         for (const h of headers) {
             const repoTarget = handle.repoIndexTargets?.get(h.id);
-            if (repoTarget !== undefined) {
-                expected.set(repoTarget, h);
+            const target = repoTarget ?? relative(handle.writableRoot, canonicalize(join(scopeDirFor(this.memoryDir, this.controlDir, h.scope), `${h.slug}.md`)));
+            if (excludedIds.has(h.id)) {
+                excludedTargets.add(target);
                 continue;
             }
-            const file = join(scopeDirFor(this.memoryDir, this.controlDir, h.scope), `${h.slug}.md`);
-            expected.set(relative(handle.writableRoot, canonicalize(file)), h);
+            expected.set(target, h);
         }
         const covered = new Set();
         const keptByTarget = new Map();
@@ -821,6 +1134,10 @@ export class MemoryEngine {
                     keptLines.push(line);
                 continue;
             }
+            if (excludedTargets.has(target)) {
+                warnings?.push(`MEMORY.md index line removed: ${target} is withheld (challenged or unsettled) — its content stays off the injected index`);
+                continue;
+            }
             if (covered.has(target)) {
                 if (line === keptByTarget.get(target))
                     continue;

package/dist/core/memory-engine/header-hints.d.ts

@@ -0,0 +1,30 @@
+/**
+ * design/180 裁决 C — the v2 header hints, read-only, over `frontmatter.extra`.
+ *
+ * The v2 header fields (pinned / triggers / last-confirmed / applies-when) are DELIBERATELY not
+ * typed structure positions: the parser's closed grammar keeps unknown lines VERBATIM in `extra`,
+ * `extra` participates in the entry rev, and the sync wire carries it — so a file with these lines
+ * computes the SAME rev on every client vintage (old and new), and no backend/sync twin owes an
+ * upgrade. Promoting them to typed fields would make the same bytes hash to two different revs
+ * across a mixed fleet (the provenance note in frontmatter.ts names that exact incident shape).
+ *
+ * This accessor is the ONLY consumer-side reading: pure, lenient, and closed over bad values —
+ * a malformed line reads as FIELD ABSENT, never an error and never a partial adoption. Nothing in
+ * the engine writes these lines; the model does (the preference-discipline paragraph teaches it),
+ * because an engine-written confirmation would forge the usage evidence it is supposed to record.
+ */
+/** The parsed v2 hints. Every field is absent unless a well-formed line was found. */
+export interface V2HeaderHints {
+    /** `pinned: true` — only the exact literal counts (anything else = absent). */
+    pinned?: boolean;
+    /** `triggers: a, b, c` — comma-split, trimmed, empties dropped; an empty result = absent. */
+    triggers?: string[];
+    /** `last-confirmed: YYYY-MM-DD…` — kept as the raw string when it starts with an ISO-date shape;
+     *  anything else = absent (bad values must not masquerade as confirmations). */
+    lastConfirmedAt?: string;
+    /** `applies-when: <free text>` — non-empty free text, trimmed. */
+    appliesWhen?: string;
+}
+/** Read the v2 header hints out of an entry's preserved-verbatim `extra` lines. First well-formed
+ *  occurrence of each key wins (duplicate lines are model bookkeeping noise, not a merge input). */
+export declare function readV2HeaderHints(extra: readonly string[] | undefined): V2HeaderHints;

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

@@ -0,0 +1,41 @@
+const LINE_RE = /^\s*([A-Za-z][A-Za-z0-9_-]*):\s*(.*?)\s*$/;
+const ISO_DATE_PREFIX_RE = /^\d{4}-\d{2}-\d{2}(?:$|[T\s])/;
+export function readV2HeaderHints(extra) {
+    const out = {};
+    if (extra === undefined)
+        return out;
+    for (const line of extra) {
+        const m = LINE_RE.exec(line);
+        if (m === null)
+            continue;
+        const [, key, value] = m;
+        switch (key) {
+            case "pinned":
+                if (out.pinned === undefined && value === "true")
+                    out.pinned = true;
+                break;
+            case "triggers": {
+                if (out.triggers !== undefined)
+                    break;
+                const items = value
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter((s) => s !== "");
+                if (items.length > 0)
+                    out.triggers = items;
+                break;
+            }
+            case "last-confirmed":
+                if (out.lastConfirmedAt === undefined && ISO_DATE_PREFIX_RE.test(value))
+                    out.lastConfirmedAt = value;
+                break;
+            case "applies-when":
+                if (out.appliesWhen === undefined && value !== "")
+                    out.appliesWhen = value;
+                break;
+            default:
+                break;
+        }
+    }
+    return out;
+}

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

@@ -1,8 +1,9 @@
-export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, 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, } from "./engine.js";
+export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, MEMORY_PREFERENCE_DISCIPLINE, 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, } from "./engine.js";
 export { MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, type MemorySearchDetails, type MemorySearchHit, type MemoryGetDetails, } from "./tools.js";
 export { scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE } from "./scan.js";
 export { FileMemoryEngineBackend, scanEntryFiles, MEMORY_INDEX_FILENAME, DEFAULT_MAX_ENTRY_DEPTH, type ScannedEntryFile } from "./file-backend.js";
-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, } from "./layout.js";
+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, type V2HeaderHints } from "./header-hints.js";
 export { parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, type ParsedEntryFile } from "./frontmatter.js";
 export type { MemoryBackend, MemoryEntry, MemoryEntryFrontmatter, MemoryEntryHeader, ScoredMemoryEntry, NotePatch, PatchReport, MaterializedFile, MemorySessionHandle, HarvestReport, HarvestRejection, HarvestRejectionCode, MemoryAnnouncement, ScanFinding, } from "./types.js";
 export { memoryBackendContract, assertMemoryBackendSearchEquivalence, type MemoryBackendContractHooks, } from "./memory-backend-contract.js";

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

@@ -1,8 +1,9 @@
-export { MemoryEngine, buildMemoryInstruction, truncateIndex, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, 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, MEMORY_PREFERENCE_DISCIPLINE, 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 { MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, } from "./tools.js";
 export { scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE } from "./scan.js";
 export { FileMemoryEngineBackend, scanEntryFiles, MEMORY_INDEX_FILENAME, DEFAULT_MAX_ENTRY_DEPTH } from "./file-backend.js";
-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, } from "./layout.js";
+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 } from "./header-hints.js";
 export { parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile } from "./frontmatter.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";