@sema-agent/core 7.21.1 → 7.23.0

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

@@ -430,6 +430,23 @@ export declare function bumpScanFuse(controlDir: string, key: string): number;
 export declare function readIndexRevs(controlDir: string): Record<string, string>;
 export declare function writeIndexRevs(controlDir: string, revs: Record<string, string>): void;
 export declare function scanFuseCount(controlDir: string, key: string): number;
+/**
+ * @contract memory.session_incarnation.proven_mismatch_only — only a PROVEN mismatch (both sides
+ * known and different) separates a record from the identity reading it; an absent incarnation on
+ * either side — a record written before the axis existed, a deployment that wires no resolver, a
+ * resolver that threw, a synthesized fail-closed record, a record imported from another plane —
+ * always BINDS, which is the pre-incarnation behavior. Every leg's conservative direction is
+ * therefore its old one, and the only way to lose a binding is to prove it belongs to someone else.
+ */
+export declare function sessionRecordBindsIncarnation(recorded: string | undefined, asking: string | undefined): boolean;
+/** The incarnation this layer ACTS on: an unusable token is the unnamed occupant, never a throw. */
+export declare function usableSessionIncarnation(raw: string | undefined): string | undefined;
+/** How a per-session record read names the identity reading; absent ⇒ every record binds. */
+export interface SessionIdentityRead {
+    incarnation?: string;
+    /** Called when a standing record was SET ASIDE as another occupant's, with the incarnation it carries — never silent. */
+    onSeparated?: (recorded: string) => void;
+}
 /** Directory (under the control plane) holding one marker file per polluted session. */
 export declare const SESSION_POLLUTION_DIR = "session-pollution";
 export interface SessionPollutionRecord {
@@ -440,6 +457,9 @@ export interface SessionPollutionRecord {
      *  honestly cause-less (the mint then falls back to `"observed"`); old readers narrow-take the
      *  two fields they know. */
     cause?: import("./types.js").MemoryOriginCause;
+    /** the occupant that minted this record ({@link sessionRecordBindsIncarnation}). ADDITIVE:
+     *  absent (no resolver wired, or written before the axis) ⇒ it binds every occupant. */
+    incarnation?: string;
 }
 /**
  * Mark `sessionId` polluted (idempotent; the FIRST record wins — `wx` create refuses overwrite).
@@ -454,13 +474,13 @@ export interface SessionPollutionRecord {
  * stays polluted for this process either way).
  */
 export type SessionPollutionMarkOutcome = "created" | "existed" | "unpersisted";
-export declare function markSessionPolluted(controlDir: string, sessionId: string, reason: string, now: () => number, cause?: import("./types.js").MemoryOriginCause): SessionPollutionMarkOutcome;
+export declare function markSessionPolluted(controlDir: string, sessionId: string, reason: string, now: () => number, cause?: import("./types.js").MemoryOriginCause, incarnation?: string): SessionPollutionMarkOutcome;
 /** Read the durable pollution record for `sessionId` (undefined = no marker).
  *  A marker that EXISTS still reads as polluted whether or not its bytes can be read or parsed
  *  (fail-closed: neither corruption nor an unreadable node may launder the state) — a synthesized
  *  record stands in. Only ABSENCE is clean, so a control plane that cannot be stat'ed at all reads
  *  clean for every session rather than disabling memory deployment-wide. */
-export declare function readSessionPollution(controlDir: string, sessionId: string): SessionPollutionRecord | undefined;
+export declare function readSessionPollution(controlDir: string, sessionId: string, identity?: SessionIdentityRead): SessionPollutionRecord | undefined;
 /**
  * design/178 v2-c §3-3 — enumerate EVERY durable pollution marker (the export snapshot's pollution
  * face; `readSessionPollution` stays the per-session read). Same fail-closed record posture as the
@@ -487,6 +507,9 @@ export declare const SESSION_CAPTURE_OPTOUT_DIR = "session-capture-optout";
 export interface SessionCaptureOptOutRecord {
     at: number;
     reason: string;
+    /** the occupant that declared this opt-out ({@link sessionRecordBindsIncarnation}).
+     *  ADDITIVE: absent ⇒ binds every occupant, which is also where a carrier that drops it lands. */
+    incarnation?: string;
 }
 /** Outcome vocabulary shared with the pollution marker (same `wx` one-way form): `"created"` ⇔ THIS
  *  call minted the record; `"existed"` ⇔ already recorded (a resumed session / an idempotent
@@ -495,8 +518,10 @@ export interface SessionCaptureOptOutRecord {
  *  "could not persist" is a named refusal, never a silent in-process-only degrade — the deliberate
  *  divergence from the pollution marker's best-effort arm). */
 export type SessionCaptureOptOutMarkOutcome = "created" | "existed" | "unpersisted";
-/** Mark `sessionId` capture-opted-out (idempotent; the FIRST record wins — `wx` refuses overwrite). */
-export declare function markSessionCaptureOptOut(controlDir: string, sessionId: string, reason: string, now: () => number): SessionCaptureOptOutMarkOutcome;
+/** Mark `sessionId` capture-opted-out (idempotent; the FIRST record wins — `wx` refuses overwrite).
+ *  Incarnation law: first-record-wins is per IDENTITY — a new occupant whose declaration meets a stranger's
+ *  standing record mints its own slot instead of answering `"existed"` ({@link sessionRecordPath}). */
+export declare function markSessionCaptureOptOut(controlDir: string, sessionId: string, reason: string, now: () => number, incarnation?: string): SessionCaptureOptOutMarkOutcome;
 /** Read the durable capture opt-out record for `sessionId` (undefined = capture is on). Fail-closed
  *  exactly like the pollution read: a record that EXISTS but cannot be read or parsed still answers
  *  opted-out (a synthesized record stands in) — corruption must not launder a privacy request back
@@ -504,7 +529,7 @@ export declare function markSessionCaptureOptOut(controlDir: string, sessionId:
  *  established (dir-level IO fault) THROWS — the engine's `sessionCaptureOptOutOrFault` catch turns
  *  it into the INDETERMINATE fault axis (same fail-closed suppression, honest attribution — see the
  *  catch below). */
-export declare function readSessionCaptureOptOut(controlDir: string, sessionId: string): SessionCaptureOptOutRecord | undefined;
+export declare function readSessionCaptureOptOut(controlDir: string, sessionId: string, identity?: SessionIdentityRead): SessionCaptureOptOutRecord | undefined;
 /**
  * Enumerate EVERY durable capture opt-out record (the consolidation eligibility arm's roster read —
  * design/383 §2.4). Same fail-closed posture as {@link listSessionPollution}: a record that exists
@@ -545,7 +570,10 @@ export declare function listSessionCaptureOptOut(controlDir: string): Record<str
  */
 export interface SessionCaptureRecordStore {
     mark(sessionId: string, record: SessionCaptureOptOutRecord): SessionCaptureOptOutMarkOutcome | Promise<SessionCaptureOptOutMarkOutcome>;
-    read(sessionId: string): SessionCaptureOptOutRecord | undefined | Promise<SessionCaptureOptOutRecord | undefined>;
+    /** `identity` names the occupant asking (absent ⇒ every record under the id binds, which is
+     *  also what a carrier that ignores the parameter keeps — no carrier has to change). One that DOES
+     *  persist the field keys its rows by (sessionId, incarnation): first record per IDENTITY wins. */
+    read(sessionId: string, identity?: SessionIdentityRead): SessionCaptureOptOutRecord | undefined | Promise<SessionCaptureOptOutRecord | undefined>;
     list(): Record<string, SessionCaptureOptOutRecord> | Promise<Record<string, SessionCaptureOptOutRecord>>;
 }
 /** The core-default {@link SessionCaptureRecordStore}: the file trio over `controlDir` (single-
@@ -600,6 +628,9 @@ export declare function readStrictSidecar(controlDir: string, fileName: string,
 export interface LineageContribution {
     lastRev: string;
     lastAt: number;
+    /** the occupant that made this contribution, carried from the staged txn at promotion as
+     *  `marked` is. Absent ⇒ unknown ⇒ the row answers every occupant of the id (the old superset). */
+    incarnation?: string;
     /** design/336 — carried from the staged row at promotion: the contribution's content (at
      *  `lastRev`) carries its external-origin marker, so the pollution retroaction sweeps owe it no
      *  challenge (the account travels with the entry). Absence = unmarked content — the sweeps'
@@ -630,6 +661,9 @@ export interface LineagePendingTxn {
     sessionId: string;
     at: number;
     rows: LineagePendingRow[];
+    /** the occupant that staged this transaction, carried onto every contribution it
+     *  promotes. Absent ⇒ unknown occupant, which binds every reader of the id. */
+    incarnation?: string;
     /** Present ⇔ `applyPatches` returned and its applied set was durably recorded. */
     credential?: {
         appliedIds: string[];
@@ -644,7 +678,7 @@ export interface LineagePendingTxn {
 }
 /** Stage this transaction's would-commit rows BEFORE `applyPatches` (write-ahead). Throws on any
  *  write/lock/corruption failure — the caller refuses the whole harvest (fail-closed). */
-export declare function stageLineagePending(controlDir: string, txnId: string, sessionId: string, rows: readonly LineagePendingRow[], now: () => number): void;
+export declare function stageLineagePending(controlDir: string, txnId: string, sessionId: string, rows: readonly LineagePendingRow[], now: () => number, incarnation?: string): void;
 /** Discard a staged transaction that never reached `applyPatches` (the pre-commit abort path —
  *  step ③ of the handshake, or a refused commit). Safe by construction: nothing was committed. */
 export declare function discardLineagePending(controlDir: string, txnId: string): void;
@@ -724,8 +758,12 @@ export declare function lineageLatchedIds(controlDir: string): Set<string>;
  *  such as "constructor" indexes truthy on EVERY plain object, so a bare lookup would attribute
  *  the WHOLE committed set to it — behind the erasure selector that phantom is a whole-store
  *  delete, the exact shape the selector type forbids. Belt over the null-proto parse rebuild:
- *  this guard stays honest even against a map minted elsewhere. */
-export declare function lineageContributionsOfSession(controlDir: string, sessionId: string): Array<{
+ *  this guard stays honest even against a map minted elsewhere.
+ *  `asking` names the occupant whose contributions are wanted: a row is kept unless it
+ *  PROVABLY belongs to another ({@link sessionRecordBindsIncarnation}). An absent `asking`, and
+ *  every unstamped row, keeps the whole by-id set — the superset this face has always answered, and
+ *  the conservative side here (a sweep that challenges too little publishes). */
+export declare function lineageContributionsOfSession(controlDir: string, sessionId: string, asking?: string): Array<{
     entryId: string;
     lastRev: string;
     lastAt: number;

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

@@ -1114,16 +1114,76 @@ export function writeIndexRevs(controlDir, revs) {
 export function scanFuseCount(controlDir, key) {
     return coerceFuse(readSidecarJson(controlDir, SCAN_FUSE_FILE))[key] ?? 0;
 }
-export const SESSION_POLLUTION_DIR = "session-pollution";
-function pollutionPath(controlDir, sessionId) {
-    return join(controlDir, SESSION_POLLUTION_DIR, `${encodeURIComponent(sessionId)}.json`);
+export function sessionRecordBindsIncarnation(recorded, asking) {
+    return recorded === undefined || asking === undefined || recorded === asking;
 }
-export function markSessionPolluted(controlDir, sessionId, reason, now, cause) {
-    const path = pollutionPath(controlDir, sessionId);
+function readIncarnationSeat(parsed) {
+    return isIncarnationSeat(parsed.incarnation) && parsed.incarnation !== undefined ? parsed.incarnation : undefined;
+}
+function isIncarnationSeat(raw) {
+    if (raw === undefined)
+        return true;
+    if (typeof raw !== "string" || raw === "")
+        return false;
+    try {
+        encodeURIComponent(raw);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function usableSessionIncarnation(raw) {
+    return isIncarnationSeat(raw) ? raw : undefined;
+}
+function sessionRecordPath(controlDir, dir, sessionId, incarnation) {
+    const name = incarnation === undefined ? `${encodeURIComponent(sessionId)}.json` : `${encodeURIComponent(sessionId)}@${encodeURIComponent(incarnation)}.json`;
+    return join(controlDir, dir, name);
+}
+function standingOwnerAt(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            return "unattributable";
+        try {
+            lstatSync(path);
+        }
+        catch {
+            return "unattributable";
+        }
+        return { owner: undefined };
+    }
     try {
-        ensureDirExists(dirname(path));
-        const record = { at: now(), reason, ...(cause !== undefined ? { cause } : {}) };
-        writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+        const parsed = JSON.parse(raw);
+        if (parsed !== null && typeof parsed === "object")
+            return { owner: readIncarnationSeat(parsed) };
+    }
+    catch {
+    }
+    return "unattributable";
+}
+function mintSessionRecordSlots(controlDir, dir, sessionId, incarnation, text) {
+    const idSlot = sessionRecordPath(controlDir, dir, sessionId);
+    try {
+        ensureDirExists(dirname(idSlot));
+        writeFileSync(idSlot, text, { encoding: "utf8", flag: "wx" });
+        return "created";
+    }
+    catch (err) {
+        if (!(err instanceof Error && "code" in err && err.code === "EEXIST"))
+            return "unpersisted";
+    }
+    const own = usableSessionIncarnation(incarnation);
+    const standing = standingOwnerAt(idSlot);
+    const vouches = standing !== "unattributable" && (standing.owner === undefined || standing.owner === own);
+    const unnamed = vouches || own === undefined ? undefined : standingOwnerAt(sessionRecordPath(controlDir, dir, sessionId, ""));
+    if (vouches || (unnamed !== undefined && unnamed !== "unattributable" && unnamed.owner === undefined))
+        return "existed";
+    try {
+        writeFileSync(sessionRecordPath(controlDir, dir, sessionId, own ?? ""), text, { encoding: "utf8", flag: "wx" });
         return "created";
     }
     catch (err) {
@@ -1132,15 +1192,59 @@ export function markSessionPolluted(controlDir, sessionId, reason, now, cause) {
         return "unpersisted";
     }
 }
-export function readSessionPollution(controlDir, sessionId) {
-    const path = pollutionPath(controlDir, sessionId);
+function bindOrSeparate(record, identity, asking, unknownSlot) {
+    if (sessionRecordBindsIncarnation(record.incarnation, asking))
+        return record;
+    const unnamed = unknownSlot();
+    if (unnamed !== undefined && sessionRecordBindsIncarnation(unnamed.incarnation, asking))
+        return unnamed;
+    if (record.incarnation !== undefined)
+        identity?.onSeparated?.(record.incarnation);
+    return undefined;
+}
+function sessionIdOfRecordName(name) {
+    if (!name.endsWith(".json"))
+        return undefined;
+    const stem = name.slice(0, -".json".length);
+    const at = stem.indexOf("@");
+    try {
+        return decodeURIComponent(at < 0 ? stem : stem.slice(0, at));
+    }
+    catch {
+        return undefined;
+    }
+}
+export const SESSION_POLLUTION_DIR = "session-pollution";
+function pollutionPath(controlDir, sessionId, incarnation) {
+    return sessionRecordPath(controlDir, SESSION_POLLUTION_DIR, sessionId, incarnation);
+}
+export function markSessionPolluted(controlDir, sessionId, reason, now, cause, incarnation) {
+    const record = { at: now(), reason, ...(cause !== undefined ? { cause } : {}), ...(incarnation !== undefined ? { incarnation } : {}) };
+    return mintSessionRecordSlots(controlDir, SESSION_POLLUTION_DIR, sessionId, incarnation, `${JSON.stringify(record, null, 2)}\n`);
+}
+export function readSessionPollution(controlDir, sessionId, identity) {
+    const asking = usableSessionIncarnation(identity?.incarnation);
+    if (asking !== undefined) {
+        const own = readPollutionAt(pollutionPath(controlDir, sessionId, asking));
+        if (own !== undefined)
+            return own;
+    }
+    const unnamedSlot = () => readPollutionAt(pollutionPath(controlDir, sessionId, ""));
+    const standing = readPollutionAt(pollutionPath(controlDir, sessionId));
+    return standing === undefined ? unnamedSlot() : bindOrSeparate(standing, identity, asking, unnamedSlot);
+}
+function readPollutionAt(path) {
     let raw;
     try {
         raw = readFileSync(path, "utf8");
     }
     catch {
-        if (!existsSync(path))
+        try {
+            lstatSync(path);
+        }
+        catch {
             return undefined;
+        }
         return { at: 0, reason: "pollution marker present but unreadable (kept fail-closed)" };
     }
     try {
@@ -1150,8 +1254,9 @@ export function readSessionPollution(controlDir, sessionId) {
             const reason = parsed.reason;
             const cause = parsed.cause;
             const knownCause = typeof cause === "string" && MEMORY_ORIGIN_CAUSES.includes(cause) ? cause : undefined;
+            const incarnation = readIncarnationSeat(parsed);
             if (typeof at === "number" && typeof reason === "string")
-                return { at, reason, ...(knownCause !== undefined ? { cause: knownCause } : {}) };
+                return { at, reason, ...(knownCause !== undefined ? { cause: knownCause } : {}), ...(incarnation !== undefined ? { incarnation } : {}) };
         }
     }
     catch {
@@ -1171,16 +1276,10 @@ export function listSessionPollution(controlDir) {
     }
     const out = Object.create(null);
     for (const name of names.sort()) {
-        if (!name.endsWith(".json"))
+        const sessionId = sessionIdOfRecordName(name);
+        if (sessionId === undefined || Object.prototype.hasOwnProperty.call(out, sessionId))
             continue;
-        let sessionId;
-        try {
-            sessionId = decodeURIComponent(name.slice(0, -".json".length));
-        }
-        catch {
-            continue;
-        }
-        const rec = readSessionPollution(controlDir, sessionId);
+        const rec = readPollutionAt(join(dir, name));
         if (rec !== undefined)
             out[sessionId] = rec;
     }
@@ -1201,25 +1300,25 @@ export function importSessionPollution(controlDir, sessionId, record) {
     return standing !== undefined && standing.at === record.at && standing.reason === record.reason ? "already" : "divergent";
 }
 export const SESSION_CAPTURE_OPTOUT_DIR = "session-capture-optout";
-function captureOptOutPath(controlDir, sessionId) {
-    return join(controlDir, SESSION_CAPTURE_OPTOUT_DIR, `${encodeURIComponent(sessionId)}.json`);
+function captureOptOutPath(controlDir, sessionId, incarnation) {
+    return sessionRecordPath(controlDir, SESSION_CAPTURE_OPTOUT_DIR, sessionId, incarnation);
 }
-export function markSessionCaptureOptOut(controlDir, sessionId, reason, now) {
-    const path = captureOptOutPath(controlDir, sessionId);
-    try {
-        ensureDirExists(dirname(path));
-        const record = { at: now(), reason };
-        writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
-        return "created";
-    }
-    catch (err) {
-        if (err instanceof Error && "code" in err && err.code === "EEXIST")
-            return "existed";
-        return "unpersisted";
+export function markSessionCaptureOptOut(controlDir, sessionId, reason, now, incarnation) {
+    const record = { at: now(), reason, ...(incarnation !== undefined ? { incarnation } : {}) };
+    return mintSessionRecordSlots(controlDir, SESSION_CAPTURE_OPTOUT_DIR, sessionId, incarnation, `${JSON.stringify(record, null, 2)}\n`);
+}
+export function readSessionCaptureOptOut(controlDir, sessionId, identity) {
+    const asking = usableSessionIncarnation(identity?.incarnation);
+    if (asking !== undefined) {
+        const own = readCaptureOptOutAt(captureOptOutPath(controlDir, sessionId, asking));
+        if (own !== undefined)
+            return own;
     }
+    const unnamedSlot = () => readCaptureOptOutAt(captureOptOutPath(controlDir, sessionId, ""));
+    const standing = readCaptureOptOutAt(captureOptOutPath(controlDir, sessionId));
+    return standing === undefined ? unnamedSlot() : bindOrSeparate(standing, identity, asking, unnamedSlot);
 }
-export function readSessionCaptureOptOut(controlDir, sessionId) {
-    const path = captureOptOutPath(controlDir, sessionId);
+function readCaptureOptOutAt(path) {
     let raw;
     try {
         raw = readFileSync(path, "utf8");
@@ -1249,8 +1348,9 @@ export function readSessionCaptureOptOut(controlDir, sessionId) {
         if (parsed !== null && typeof parsed === "object") {
             const at = parsed.at;
             const reason = parsed.reason;
+            const incarnation = readIncarnationSeat(parsed);
             if (typeof at === "number" && typeof reason === "string")
-                return { at, reason };
+                return { at, reason, ...(incarnation !== undefined ? { incarnation } : {}) };
         }
     }
     catch {
@@ -1270,16 +1370,10 @@ export function listSessionCaptureOptOut(controlDir) {
     }
     const out = Object.create(null);
     for (const name of names.sort()) {
-        if (!name.endsWith(".json"))
+        const sessionId = sessionIdOfRecordName(name);
+        if (sessionId === undefined || Object.prototype.hasOwnProperty.call(out, sessionId))
             continue;
-        let sessionId;
-        try {
-            sessionId = decodeURIComponent(name.slice(0, -".json".length));
-        }
-        catch {
-            continue;
-        }
-        const rec = readSessionCaptureOptOut(controlDir, sessionId);
+        const rec = readCaptureOptOutAt(join(dir, name));
         if (rec !== undefined)
             out[sessionId] = rec;
     }
@@ -1287,8 +1381,8 @@ export function listSessionCaptureOptOut(controlDir) {
 }
 export function fileSessionCaptureRecordStore(controlDir) {
     return {
-        mark: (sessionId, record) => markSessionCaptureOptOut(controlDir, sessionId, record.reason, () => record.at),
-        read: (sessionId) => readSessionCaptureOptOut(controlDir, sessionId),
+        mark: (sessionId, record) => markSessionCaptureOptOut(controlDir, sessionId, record.reason, () => record.at, record.incarnation),
+        read: (sessionId, identity) => readSessionCaptureOptOut(controlDir, sessionId, identity),
         list: () => listSessionCaptureOptOut(controlDir),
     };
 }
@@ -1461,6 +1555,9 @@ function coerceLineage(raw) {
             }
             if (row.marked !== undefined && row.marked !== true)
                 throw badShape(`committed[${JSON.stringify(entryId)}][${JSON.stringify(sid)}] marked`);
+            if (!isIncarnationSeat(row.incarnation)) {
+                throw badShape(`committed[${JSON.stringify(entryId)}][${JSON.stringify(sid)}] incarnation`);
+            }
         }
     }
     for (const [txnId, t] of Object.entries(r.pending)) {
@@ -1470,6 +1567,8 @@ function coerceLineage(raw) {
         }
         if (txn.kind !== undefined && txn.kind !== "latch-only")
             throw badShape(`pending[${JSON.stringify(txnId)}] kind`);
+        if (!isIncarnationSeat(txn.incarnation))
+            throw badShape(`pending[${JSON.stringify(txnId)}] incarnation`);
         for (const row of txn.rows) {
             const p = row;
             if (!p || typeof p !== "object" || typeof p.entryId !== "string" || typeof p.rev !== "string")
@@ -1498,9 +1597,9 @@ function coerceLineage(raw) {
         pending[txnId] = t;
     return { version: 1, committed, pending };
 }
-export function stageLineagePending(controlDir, txnId, sessionId, rows, now) {
+export function stageLineagePending(controlDir, txnId, sessionId, rows, now, incarnation) {
     lockedStrictUpdate(controlDir, LINEAGE_FILE, "memory lineage ledger", coerceLineage, (rec) => {
-        rec.pending[txnId] = { sessionId, at: now(), rows: [...rows] };
+        rec.pending[txnId] = { sessionId, at: now(), rows: [...rows], ...(incarnation !== undefined ? { incarnation } : {}) };
         return { next: rec, result: undefined };
     });
 }
@@ -1536,7 +1635,7 @@ export function promoteLineagePending(controlDir, txnId, now) {
             if (!applied.has(row.entryId))
                 continue;
             const sessions = (rec.committed[row.entryId] ??= Object.create(null));
-            sessions[txn.sessionId] = { lastRev: row.rev, lastAt: at, ...(row.marked === true ? { marked: true } : {}) };
+            sessions[txn.sessionId] = { lastRev: row.rev, lastAt: at, ...(row.marked === true ? { marked: true } : {}), ...(txn.incarnation !== undefined ? { incarnation: txn.incarnation } : {}) };
             promoted.push({ entryId: row.entryId, sessionId: txn.sessionId, rev: row.rev, ...(row.marked === true ? { marked: true } : {}) });
         }
         delete rec.pending[txnId];
@@ -1562,7 +1661,7 @@ export function adjudicateLineagePending(controlDir, txnId, action, now) {
             if (applied !== undefined && !applied.has(row.entryId))
                 continue;
             const sessions = (rec.committed[row.entryId] ??= Object.create(null));
-            sessions[txn.sessionId] = { lastRev: row.rev, lastAt: at, ...(row.marked === true ? { marked: true } : {}) };
+            sessions[txn.sessionId] = { lastRev: row.rev, lastAt: at, ...(row.marked === true ? { marked: true } : {}), ...(txn.incarnation !== undefined ? { incarnation: txn.incarnation } : {}) };
             promoted.push({ entryId: row.entryId, sessionId: txn.sessionId, rev: row.rev, ...(row.marked === true ? { marked: true } : {}) });
         }
         delete rec.pending[txnId];
@@ -1586,7 +1685,7 @@ export function reconcileLineage(controlDir, now) {
                     continue;
                 at ??= now();
                 const sessions = (rec.committed[row.entryId] ??= Object.create(null));
-                sessions[txn.sessionId] = { lastRev: row.rev, lastAt: at, ...(row.marked === true ? { marked: true } : {}) };
+                sessions[txn.sessionId] = { lastRev: row.rev, lastAt: at, ...(row.marked === true ? { marked: true } : {}), ...(txn.incarnation !== undefined ? { incarnation: txn.incarnation } : {}) };
                 promoted.push({ entryId: row.entryId, sessionId: txn.sessionId, rev: row.rev, ...(row.marked === true ? { marked: true } : {}) });
             }
             delete rec.pending[txnId];
@@ -1663,13 +1762,14 @@ export function lineageLatchedIds(controlDir) {
             out.add(row.entryId);
     return out;
 }
-export function lineageContributionsOfSession(controlDir, sessionId) {
+export function lineageContributionsOfSession(controlDir, sessionId, asking) {
     const rec = coerceLineage(readStrictSidecar(controlDir, LINEAGE_FILE, "memory lineage ledger"));
     const out = [];
     for (const [entryId, sessions] of Object.entries(rec.committed)) {
         const c = Object.prototype.hasOwnProperty.call(sessions, sessionId) ? sessions[sessionId] : undefined;
-        if (c !== undefined)
-            out.push({ entryId, lastRev: c.lastRev, lastAt: c.lastAt, ...(c.marked === true ? { marked: true } : {}) });
+        if (c === undefined || !sessionRecordBindsIncarnation(c.incarnation, asking))
+            continue;
+        out.push({ entryId, lastRev: c.lastRev, lastAt: c.lastAt, ...(c.marked === true ? { marked: true } : {}) });
     }
     return out;
 }

package/dist/core/memory-engine/session-incarnation.d.ts

@@ -0,0 +1,27 @@
+import { type MemoryPartitionIncidentSink, type SessionIdentityRead } from "./layout.js";
+/** The current occupant's token, and the identity seat a per-session record read is made under. */
+export interface SessionIncarnationSeat {
+    incarnationOf(sessionId: string): string | undefined;
+    identityRead(sessionId: string): SessionIdentityRead;
+}
+/** Build the seat over a host resolver (absent ⇒ nothing stamped, nothing asked, every record binds
+ *  by id — the pre-incarnation answer). Both disclosures are DEDUPED on the axis their fact belongs to: the resolver
+ *  fault once per engine (a wiring fact), a separation once per session id (a fact about that id). */
+export declare function createSessionIncarnationSeat(input: {
+    resolve: ((session: {
+        sessionId: string;
+    }) => string | undefined) | undefined;
+    onIncident: MemoryPartitionIncidentSink | undefined;
+}): SessionIncarnationSeat;
+/** Remember an in-process record under its session id, FIRST-WINS PER IDENTITY: this map is the
+ *  durable half's fallback exactly when the durable write failed, so keeping only the first
+ *  occupant's row would leave the next one unprotected on the one path it exists to cover. */
+export declare function rememberForIdentity<T extends {
+    incarnation?: string;
+}>(map: Map<string, T[]>, sessionId: string, record: T): void;
+/** The remembered record that BINDS `asking` ({@link sessionRecordBindsIncarnation}), if any. */
+export declare function recalledForIdentity<T extends {
+    incarnation?: string;
+}>(map: Map<string, T[]>, sessionId: string, asking: string | undefined): T | undefined;
+/** The first record remembered for `sessionId` by ANY occupant — for the id-blind faces. */
+export declare function recalledForAnyIdentity<T>(map: Map<string, T[]>, sessionId: string): T | undefined;

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

@@ -0,0 +1,63 @@
+import { sessionRecordBindsIncarnation, usableSessionIncarnation } from "./layout.js";
+export function createSessionIncarnationSeat(input) {
+    const { resolve, onIncident } = input;
+    let faultAnnounced = false;
+    const separationAnnounced = new Set();
+    const disclose = (code, message) => {
+        if (onIncident === undefined)
+            return;
+        try {
+            const e = new Error(message);
+            e.code = code;
+            onIncident(e);
+        }
+        catch {
+        }
+    };
+    const incarnationOf = (sessionId) => {
+        if (resolve === undefined)
+            return undefined;
+        try {
+            const answer = resolve({ sessionId });
+            return usableSessionIncarnation(answer);
+        }
+        catch (err) {
+            if (!faultAnnounced) {
+                faultAnnounced = true;
+                disclose("memory.session_incarnation_unreadable", `the session incarnation resolver threw (${err instanceof Error ? err.message : String(err)}) — this run cannot tell one occupant of a session id from the next, so every durable session record binds by id alone (the conservative reading, and the behavior of a deployment that wires no resolver)`);
+            }
+            return undefined;
+        }
+    };
+    return {
+        incarnationOf,
+        identityRead: (sessionId) => {
+            const incarnation = incarnationOf(sessionId);
+            return {
+                ...(incarnation !== undefined ? { incarnation } : {}),
+                onSeparated: (recorded) => {
+                    if (separationAnnounced.has(sessionId))
+                        return;
+                    separationAnnounced.add(sessionId);
+                    disclose("memory.session_incarnation_mismatch", `a durable record stands for session ${sessionId} but it was minted by a DIFFERENT occupant of that id (recorded incarnation ${JSON.stringify(recorded)}, this run ${JSON.stringify(incarnation)}) — it does not bind this run and the record is kept where it is. Either the id was recycled after its previous session was deleted, or the deployment's incarnation resolver is not stable for the life of one session`);
+                },
+            };
+        },
+    };
+}
+export function rememberForIdentity(map, sessionId, record) {
+    const rows = map.get(sessionId);
+    if (rows === undefined) {
+        map.set(sessionId, [record]);
+        return;
+    }
+    if (rows.some((r) => r.incarnation === record.incarnation))
+        return;
+    rows.push(record);
+}
+export function recalledForIdentity(map, sessionId, asking) {
+    return map.get(sessionId)?.find((r) => sessionRecordBindsIncarnation(r.incarnation, asking));
+}
+export function recalledForAnyIdentity(map, sessionId) {
+    return map.get(sessionId)?.[0];
+}

package/dist/core/parent-spec-seat.d.ts

@@ -12,7 +12,7 @@ import type { OnQuestion } from "./ask-question.js";
 import type { ToolExecuteContext } from "./tool-spec.js";
 import type { TaskSpec } from "./types.js";
 /** The fields of a spec the seat carries — one `Pick`, shared by the mint's input and the apply's target. */
-export type ParentSpecSeatFields = Pick<TaskSpec, "principal" | "oneShot" | "clientContext" | "onQuestion" | "additionalDirectories" | "additionalReadDirectories" | "envFacts" | "memoryPersistenceCapable">;
+export type ParentSpecSeatFields = Pick<TaskSpec, "principal" | "oneShot" | "clientContext" | "onQuestion" | "additionalDirectories" | "additionalReadDirectories" | "envFacts" | "memoryPersistenceCapable" | "memory">;
 /**
  * The seat a run hands its children. Every member is the parent's own value, frozen at mint (arrays copied and
  * frozen; the facts object copied). Members present iff the parent carries them — an absent member is "nothing to
@@ -26,6 +26,8 @@ export type ParentSpecSeatFields = Pick<TaskSpec, "principal" | "oneShot" | "cli
  *  · `envFacts` — the sandbox facts (profile / egress / scratchpad).
  *  · `memoryPersistenceCapable` — the deployment's DECLARED persistence statement: `false` is a REMOVAL (floor),
  *    `true` a default a child's own declaration may narrow.
+ *  · `memoryOff` — the request-level "memory is off" FACT (`spec.memory.enabled === false`): a REMOVAL
+ *    (floor) that REWRITES the child's own memory declaration instead of travelling as a value.
  */
 export interface ParentSpecSeat {
     readonly principal?: string;
@@ -36,14 +38,15 @@ export interface ParentSpecSeat {
     readonly additionalReadDirectories?: readonly string[];
     readonly envFacts?: TaskSpec["envFacts"];
     readonly memoryPersistenceCapable?: boolean;
+    readonly memoryOff?: true;
 }
 /** Mint the seat off the parent's REBOUND spec and its frozen question face (spec over deps — the caller resolves it once,
  *  the same value the parent's own question routing reads). Absent fields stay absent; `oneShot` only when `true`. */
 export declare function parentSpecSeatOf(spec: Omit<ParentSpecSeatFields, "onQuestion">, frozenOnQuestion: OnQuestion | undefined): ParentSpecSeat;
 /**
  * Apply the seat to a child spec — ONE law for every member, both lanes:
- *   a value the child spec already carries WINS; the seat FILLS an unset one; the two REMOVAL values
- *   (`oneShot: true`, `memoryPersistenceCapable: false`) land UNCONDITIONALLY.
+ *   a value the child spec already carries WINS; the seat FILLS an unset one; the three REMOVAL values
+ *   (`oneShot: true`, `memoryPersistenceCapable: false`, `memoryOff: true`) land UNCONDITIONALLY.
  * "Already carries" is the child's own authorship — a deployment baseline, a trusted script, an agent definition's
  * fold (the Task lane folds the definition's `memoryPersistenceCapable` before applying; the workflow lane applies at
  * the launch site AFTER the agentType fold) — so a definition may narrow a parent `true` to `false`, a baseline-pinned
@@ -52,6 +55,15 @@ export declare function parentSpecSeatOf(spec: Omit<ParentSpecSeatFields, "onQue
  * No seat (a tool running outside a Runner task) ⇒ the child spec is returned as is.
  */
 export declare function applyParentSpecSeat<S extends ParentSpecSeatFields>(child: S, seat: ParentSpecSeat | undefined): S;
+/** The ONE way the memory-off floor is written onto a spec — the seat's apply above and the resume lane's
+ *  clamp fold both call it: keep every field the spec authored (scopes, write scope, content-safety knobs)
+ *  and state `enabled: false` over them. Returning a value rather than deleting the key IS the mechanism:
+ *  the next seat mint reads `spec.memory.enabled === false`, so a spec whose `memory` was removed would end
+ *  the floor one level down. A spec that declared nothing gets the bare `{ enabled: false }`, which the
+ *  normalizer reads as "no usable scopes" — identical to the absent declaration it replaces. */
+export declare function memoryTurnedOff(memory: TaskSpec["memory"]): NonNullable<TaskSpec["memory"]> & {
+    enabled: false;
+};
 /** The ctx keys that restate a seat member as THIS run's own fact (tools read them for scope / receipts / clamps). */
 declare const SEAT_FACTS_ON_CTX: readonly ["principal", "oneShot", "onQuestion", "memoryPersistenceCapable"];
 /**

package/dist/core/parent-spec-seat.js

@@ -8,6 +8,7 @@ export function parentSpecSeatOf(spec, frozenOnQuestion) {
         ...(spec.additionalReadDirectories !== undefined ? { additionalReadDirectories: Object.freeze([...spec.additionalReadDirectories]) } : {}),
         ...(spec.envFacts !== undefined ? { envFacts: Object.freeze({ ...spec.envFacts }) } : {}),
         ...(spec.memoryPersistenceCapable !== undefined ? { memoryPersistenceCapable: spec.memoryPersistenceCapable } : {}),
+        ...(spec.memory?.enabled === false ? { memoryOff: true } : {}),
     });
 }
 export function applyParentSpecSeat(child, seat) {
@@ -24,8 +25,12 @@ export function applyParentSpecSeat(child, seat) {
         ...fill("envFacts", (seat.envFacts !== undefined ? { ...seat.envFacts } : undefined)),
         ...(seat.oneShot === true ? { oneShot: true } : {}),
         ...(seat.memoryPersistenceCapable === false ? { memoryPersistenceCapable: false } : fill("memoryPersistenceCapable", seat.memoryPersistenceCapable)),
+        ...(seat.memoryOff === true ? { memory: memoryTurnedOff(child.memory) } : {}),
     };
 }
+export function memoryTurnedOff(memory) {
+    return { ...(memory ?? {}), enabled: false };
+}
 const SEAT_FACTS_ON_CTX = ["principal", "oneShot", "onQuestion", "memoryPersistenceCapable"];
 export function parentSpecSeatOfCtx(ctx) {
     const seat = ctx.parentSpecSeat;

package/dist/core/park-selfcheck.js

@@ -86,7 +86,7 @@ function syntheticCheckpoint(scope) {
         suspendCount: 1,
         suspendedAt: Date.now(),
         resourceLedger: { spentMicroUsd: 0, spentTokens: 0, spentTurns: 0, sliceCount: 1 },
-        humanReview: { count: 1, totalWaitMs: 0, gates: [{ kind: "human", waitMs: 0, decision: "approve" }] },
+        humanReview: { count: 1, totalWaitMs: 0, gates: [{ kind: "human", waitMs: 0, decision: "approve", toolName: "SelfCheck", toolCallId: `${scope}:selfcheck-call`, toolArg: "park self-check probe" }] },
         sourceTaskId: `${scope}:task`,
         principal: `${scope}:principal`,
         durableApproval: { scope, ttlMs: PARK_SELFCHECK_ROW_TTL_MS },