@sema-agent/core 7.30.1 → 7.31.1

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { closeSync, constants as fsConstants, existsSync, fchmodSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { accessSync, closeSync, constants as fsConstants, existsSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, sep } from "node:path";
 import { uuidv7 } from "../../internal/harness.js";
 import { MAX_MEMORY_BYTES, composeMemoryBlock, firstSentence } from "../memory.js";
@@ -11,12 +11,13 @@ import { MEMORY_PROVENANCE_RECALL_SENTENCE, memoryExposureIndexRow, parseMemoryE
 import { isInstructionEntry } from "./header-hints.js";
 import { ConsolidationRefusedError, CONSOLIDATION_FORCE_THROTTLE_FLOOR_MS, CONSOLIDATION_SEAT_FREEZE_GRACE_MS, consolidationTypeEligible, deriveProductSlug, deriveSupersededSet, isValidConsolidationPlanId, listConsolidationPlanIds, productAddPatch, quarantineCorruptPlan, readConsolidationGateFile, readConsolidationPlan, readIntentCredentials, recordActiveSetBaseline, recordConsolidationSession, sessionsSinceExcludingCurrent, recordIntentCredentials, scanRefusalCeiling, screenConsolidationOptions, supersessionFuseCeiling, updateConsolidationGate, writeConsolidationPlan, } from "./consolidation.js";
 import { deriveShadowedSet } from "./shadowing.js";
-import { classifySessionSettlements, clearHoldResolution, closeSessionAccount, disposeHold, effectiveSettlements, expireOverdueSettlements, foreignDanglingSessionAccounts, markHoldReleased, openInstructionHold, openSessionAccount, readHoldCustody, readHolds, reconcileHolds, replayExternalSettlementEffects, resolveHoldRecord, resolveSessionAccountRecord, resolveSettlementRecord, sessionSettlements, sessionUnattributedSet, emptyUnattributedSet, convertV1SidecarKeys, } from "./delegation-settlement.js";
+import { classifySessionSettlements, clearHoldResolution, closeSessionAccount, disposeHold, effectiveSettlements, expireOverdueSettlements, foreignDanglingSessionAccounts, openLayerWriters, terminateSessionAccount, sessionAccountLeg, markHoldReleased, openInstructionHold, openSessionAccount, readHoldCustody, readHolds, reconcileHolds, replayExternalSettlementEffects, resolveHoldRecord, resolveSessionAccountRecord, resolveSettlementRecord, sessionSettlements, sessionUnattributedSet, emptyUnattributedSet, convertV1SidecarKeys, } from "./delegation-settlement.js";
 import { noReplaceRestore, retireStagingToCustody, stagingPathBeside } from "./delegation-settlement.js";
+import { landedUndecided, layerDigest, layerObservationLookup, readOnlyLayerCandidates, readOnlyLayerCensus, recordLayerObservations, settleUndecidedLayerObservations, observationBacked, sameObservation, undecidedLayerObservations } from "./layer-observations.js";
 import { markOriginClearanceTombstoned, openOriginClearance, readOriginClearances, settleOriginClearance } from "./origin-clearance.js";
 import { DEFAULT_MAX_ENTRY_DEPTH, MEMORY_INDEX_FILENAME, canonicalJsonStringify, captureErasureInput, erasureRequestInvalid, erasureSelectHash, scanEntryFiles, } from "./file-backend.js";
 import { assembleMemoryExportBundle, computeMemoryBundleHash, memoryBundleInvalid, } from "./export-bundle.js";
-import { QUARANTINE_DIR, SCAN_FUSE_THRESHOLD, quarantineAndTombstone, restoreContainedBaseline, readIndexRevs, writeIndexRevs, bumpScanFuse, scanFuseKey, canonicalize, adoptRootScopeLayout, clearScanFuse, adoptCanonicalKeyedControlDir, deriveControlPlaneDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, ensureDirExists, markSessionPolluted, readSessionPollution, fileSessionCaptureRecordStore, recordRetrievedAccount, writeFileNoFollow, readRetrievedAccount, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirFor, appendChallengeEvents, appendLineageAudit, rebuildStrictControlPlaneLedger, isStrictControlPlaneLedgerCorrupt, CHALLENGE_LEDGER_MAX_EVENTS, adjudicateLineagePending, challengedEntryIds, clearLineageForEntries, discardLineagePending, lineageAccountOfEntry, lineageContributionsOfSession, lineageLatchedIds, promoteLineagePending, readChallengeEvents, readChallengedHistory, readLineageRecord, recordChallengedHistory, recordLineageCredential, reconcileLineage, readProjectionDebts, resolveChallengeEvent, settleProjectionDebts, stageLineagePending, stageProjectionDebts, } from "./layout.js";
+import { QUARANTINE_DIR, SCAN_FUSE_THRESHOLD, quarantineAndTombstone, restoreContainedBaseline, readIndexRevs, writeIndexRevs, bumpScanFuse, scanFuseKey, canonicalize, landingPathOf, storeTargetEscape, TARGET_OUTSIDE_STORE, adoptRootScopeLayout, clearScanFuse, adoptCanonicalKeyedControlDir, deriveControlPlaneDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, ensureDirExists, markSessionPolluted, readSessionPollution, fileSessionCaptureRecordStore, recordRetrievedAccount, writeFileNoFollow, withPermissionRemedy, permissionRemedyOf, readRetrievedAccount, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirFor, appendChallengeEvents, appendLineageAudit, rebuildStrictControlPlaneLedger, isStrictControlPlaneLedgerCorrupt, CHALLENGE_LEDGER_MAX_EVENTS, adjudicateLineagePending, challengedEntryIds, clearLineageForEntries, discardLineagePending, lineageAccountOfEntry, lineageContributionsOfSession, lineageLatchedIds, promoteLineagePending, readChallengeEvents, readChallengedHistory, readLineageRecord, recordChallengedHistory, recordLineageCredential, reconcileLineage, readProjectionDebts, resolveChallengeEvent, settleProjectionDebts, stageLineagePending, stageProjectionDebts, } from "./layout.js";
 import { createSessionIncarnationSeat, recalledForAnyIdentity, recalledForIdentity, rememberForIdentity } from "./session-incarnation.js";
 import { scanMemoryFileName, scanMemoryWrite, scanRemediation } from "./scan.js";
 import { writableRootOf } from "./types.js";
@@ -301,9 +302,15 @@ export function memoryConsolidationRefusedNotice(input) {
         },
     };
 }
+const INDEX_WRITE_REFUSED = "the derived memory index could NOT be written";
+function unexpectedLayerFile(handle, c) {
+    return { path: relative(handle.memoryDir, c.path), code: "readonly_layer", reason: "a file appeared in a read-only inherited memory layer during this session — it is recorded as an unexpected write and never adopted into memory" };
+}
+const STALE_LEG_NOTE = "memory session account: this harvest belongs to an earlier leg of the session (a later leg re-opened the account while it ran) — its account close and leg end were not written over the later leg";
 export class MemoryEngine {
     backend;
     memoryDir;
+    mountedRoot;
     controlDir;
     now;
     perScopeBudgetBytes;
@@ -315,6 +322,7 @@ export class MemoryEngine {
     holdSettleTimeoutMs;
     provenance;
     onIncident;
+    unsettleableDisclosed = false;
     backendPinnedRoot;
     constructor(opts) {
         if (opts.provenance !== undefined && opts.provenance !== "off" && opts.provenance !== "carry") {
@@ -360,6 +368,18 @@ export class MemoryEngine {
         return this.provenance;
     }
     consolidation;
+    endSessionLeg(handle, sessionId) {
+        return handle.accountLeg !== undefined ? this.endLeg(sessionId, handle.accountLeg) : undefined;
+    }
+    endLeg(sessionId, leg) {
+        try {
+            return terminateSessionAccount(this.controlDir, { sessionId, now: this.now, leg });
+        }
+        catch (err) {
+            this.discloseSessionAccountIncident("the end of this session's leg could not be recorded — it keeps reading as a live writer of its layer (read-only restores there are withheld)", err);
+            return undefined;
+        }
+    }
     discloseSessionAccountIncident(what, cause) {
         const sink = this.onIncident;
         if (sink === undefined)
@@ -372,6 +392,209 @@ export class MemoryEngine {
         catch {
         }
     }
+    async detectReadOnlyLayerChanges(handle, report, admitsNothing) {
+        const candidates = [];
+        for (const m of handle.materialized.filter((x) => x.readonly)) {
+            const text = readSafe(m.path);
+            if (text === undefined) {
+                report.missing.push(m.relPath);
+                continue;
+            }
+            if (revOfText(text, m.id) === m.rev)
+                continue;
+            if ((await this.committedContentUnadopted(m.id)) === text)
+                continue;
+            const stood = handle.layerBaseline?.get(m.path) === layerDigest(text);
+            const rejection = admitsNothing
+                ? { path: m.relPath, code: "readonly_layer", reason: `a read-only inherited memory layer's file ${stood ? "differed from its committed content when this session started (not this session's write)" : "differs from what this session was served"}; this session admits nothing, so it was not restored — the bytes stay on disk for a session that may write to adjudicate` }
+                : { path: m.relPath, code: "readonly_layer", reason: stood ? "a read-only inherited memory layer's file differed from its committed content when this session started (not this session's write)" : "a read-only inherited memory layer was modified; changes to inherited layers are not writable from this session" };
+            report.rejections.push(rejection);
+            if (!admitsNothing)
+                candidates.push({ path: m.path, relPath: m.relPath, scope: m.scope, id: m.id, stood, rejection });
+        }
+        return candidates;
+    }
+    async committedContentUnadopted(id) {
+        const zeroCopy = this.backendPinnedRoot !== undefined && canonicalize(this.backendPinnedRoot) === canonicalize(this.memoryDir);
+        const view = zeroCopy ? undefined : this.backend.restrictedAdoptionView?.({ audit: false });
+        if (view === undefined)
+            return this.committedContentFor(id);
+        try {
+            const [entry] = await view.getByIds([id]);
+            if (entry !== undefined && entry.id === id)
+                return serializeEntryFile(entry);
+        }
+        catch {
+        }
+        return this.backend.readCommittedShadow?.(id) ?? readSafe(join(this.controlDir, "shadow", `${id}.md`));
+    }
+    async restoreReadOnlyLayers(candidates, report, selfLeg, root) {
+        let writers;
+        for (const c of candidates) {
+            const text = readSafe(c.path);
+            const committed = await this.committedContentUnadopted(c.id);
+            if (text !== undefined && text === committed) {
+                report.rejections = report.rejections.filter((r) => r !== c.rejection);
+                continue;
+            }
+            if (committed === undefined)
+                continue;
+            try {
+                writers ??= openLayerWriters(this.controlDir, selfLeg);
+            }
+            catch {
+                writers = { scopes: new Set(), unscoped: 1 };
+            }
+            if (writers.unscoped > 0 || writers.scopes.has(c.scope)) {
+                c.rejection.reason = `a read-only inherited memory layer's file ${c.stood ? "differed from its committed content when this session started (not this session's write)" : "differs from what this session was served"}; a session that writes this layer is open (the bytes may be its uncommitted edit), so it was not restored`;
+                report.warnings.push(`read-only layer file ${quoteId(c.relPath)} was not restored: a session that writes this layer is open, and the bytes may be its uncommitted edit`);
+                continue;
+            }
+            try {
+                this.refuseOutsideStore(root, c.path, "restoring the read-only layer file");
+                writeFileNoFollow(c.path, committed);
+                report.restored.push(c.relPath);
+            }
+            catch (err) {
+                report.warnings.push(`read-only layer file ${quoteId(c.relPath)} could NOT be restored to its committed content — the modified bytes are still on disk: ${this.writeFailureText(err)}`);
+            }
+        }
+    }
+    async observeReadOnlyLayers(handle, report, sessionId) {
+        const served = new Set(handle.materialized.filter((m) => m.readonly).map((m) => m.path));
+        const batch = { rows: [], rejections: [], undecided: [], landed: false };
+        for (const c of readOnlyLayerCandidates(this.memoryDir, this.controlDir, handle)) {
+            const by = { scope: c.scope, rel: c.rel, ...(sessionId !== undefined ? { sessionId } : {}), observedAt: this.now() };
+            if (c.id === undefined) {
+                batch.rows.push({ ...by, observedRev: c.digest });
+            }
+            else {
+                const committed = await this.committedRowOf(c.id);
+                if (committed === "undecidable") {
+                    const row = { ...by, entryId: c.id, observedRev: c.observedRev, undecided: true, observationId: uuidv7() };
+                    batch.rows.push(row);
+                    batch.undecided.push({ candidate: c, row });
+                    continue;
+                }
+                if (committed !== undefined && committed.scope === c.scope && committed.slug === c.slug && committed.rev === c.observedRev)
+                    continue;
+                batch.rows.push({ ...by, entryId: c.id, ...(committed !== undefined ? { rev: committed.rev } : {}), observedRev: c.observedRev });
+            }
+            if (!served.has(c.path)) {
+                batch.rejections.push(unexpectedLayerFile(handle, c));
+            }
+        }
+        this.landObservations(batch, report);
+        return batch;
+    }
+    landObservations(batch, report) {
+        try {
+            recordLayerObservations(this.controlDir, batch.rows);
+        }
+        catch (err) {
+            batch.failure = this.writeFailureText(err);
+            return;
+        }
+        batch.landed = true;
+        delete batch.failure;
+        report.rejections.push(...batch.rejections);
+    }
+    concludeObservations(batch, report) {
+        if (batch !== undefined && !batch.landed) {
+            report.warnings.push(`${batch.rows.length} unexpected write(s) into read-only memory layers could NOT be recorded — a later session's read may adopt them: ${batch.failure ?? "unknown failure"}`);
+        }
+        this.discloseUndecidedObservations(landedUndecided(batch).map((u) => u.candidate), report);
+    }
+    discloseUndecidedObservations(undecided, report) {
+        for (const c of undecided) {
+            report.warnings.push(`${quoteId(relative(this.memoryDir, c.path))}: changed in a read-only memory layer during this session, and whether a commit backs it could not be established (a memory transaction was pending, or the committed account could not be read) — recorded as undecided (not adopted), settled once a writing session can read the committed account`);
+        }
+    }
+    async settleUndecidedObservations(handle, report, own) {
+        let rows;
+        try {
+            rows = undecidedLayerObservations(this.controlDir);
+        }
+        catch (err) {
+            report.warnings.push(`undecided read-only-layer observations could not be read for settlement — they stay undecided (not adopted): ${this.writeFailureText(err)}`);
+            return;
+        }
+        const verdicts = new Map();
+        for (const row of rows) {
+            const committed = row.entryId !== undefined ? await this.committedRowOf(row.entryId) : "undecidable";
+            if (committed !== "undecidable")
+                verdicts.set(row, observationBacked(row, committed) ? "backed" : committed !== undefined ? { rev: committed.rev } : {});
+        }
+        try {
+            settleUndecidedLayerObservations(this.controlDir, verdicts);
+        }
+        catch (err) {
+            report.warnings.push(`undecided read-only-layer observations could not be settled — they stay undecided (not adopted): ${this.writeFailureText(err)}`);
+            return;
+        }
+        const served = new Set(handle.materialized.filter((m) => m.readonly).map((m) => m.path));
+        const stillUndecided = [];
+        for (const { candidate: c, row: mine } of own) {
+            const row = rows.find((r) => sameObservation(r, mine));
+            if (row === undefined) {
+                const refused = served.has(c.path) ? false : await this.refusedNow(mine.entryId, c.observedRev);
+                if (refused === true)
+                    report.rejections.push(unexpectedLayerFile(handle, c));
+                else if (refused === undefined)
+                    report.warnings.push(`${quoteId(relative(this.memoryDir, c.path))}: changed in a read-only memory layer during this session; another writing session settled its record first, and whether memory refuses these bytes now could not be read`);
+                continue;
+            }
+            const verdict = verdicts.get(row);
+            if (verdict === undefined)
+                stillUndecided.push(c);
+            else if (verdict !== "backed" && !served.has(c.path))
+                report.rejections.push(unexpectedLayerFile(handle, c));
+        }
+        this.discloseUndecidedObservations(stillUndecided, report);
+    }
+    async refusedNow(entryId, observedRev) {
+        const committed = entryId !== undefined ? await this.committedRowOf(entryId) : "undecidable";
+        if (entryId === undefined || committed === "undecidable")
+            return undefined;
+        try {
+            return layerObservationLookup(this.controlDir).find(entryId, committed?.rev, observedRev) !== undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    discloseUnsettleableObservations() {
+        if (this.unsettleableDisclosed || typeof this.backend.committedSnapshotOf === "function")
+            return;
+        this.unsettleableDisclosed = true;
+        const sink = this.onIncident;
+        if (sink === undefined)
+            return;
+        try {
+            const e = new Error("memory read-only layers: this backend has no committed-snapshot face (committedSnapshotOf), so whether a commit backs a change observed in a read-only layer cannot be established — every such change is recorded as undecided (not adopted), and undecided observations cannot settle on this backend");
+            e.code = "memory.observation_settlement_unavailable";
+            sink(e);
+        }
+        catch {
+        }
+    }
+    async committedRowOf(id) {
+        const face = this.backend.committedSnapshotOf;
+        if (face === undefined)
+            return "undecidable";
+        try {
+            const snap = await face.call(this.backend, id);
+            if (snap.state !== "row")
+                return undefined;
+            return { rev: snap.rev, ...(snap.binding.state === "bound" ? { scope: snap.binding.scope, slug: snap.binding.slug } : {}) };
+        }
+        catch {
+            return "undecidable";
+        }
+    }
+    writeFailureText(err) {
+        return thrownText(withPermissionRemedy(err, this.memoryDir));
+    }
     discloseAnnounceFailure(stage, cause) {
         const sink = this.onIncident;
         if (sink === undefined)
@@ -534,6 +757,7 @@ export class MemoryEngine {
             const indexPath = join(writableRoot, MEMORY_INDEX_FILENAME);
             const baseline = handle.planeBaseline !== undefined ? handle.planeBaseline.index : handle.indexText;
             try {
+                this.refuseOutsideStore(handle.memoryDir, indexPath, "sweeping the index");
                 const first = existsSync(indexPath) ? readSafe(indexPath) : undefined;
                 if (first !== undefined && first !== baseline) {
                     const onDisk = readSafe(indexPath);
@@ -557,7 +781,7 @@ export class MemoryEngine {
                 }
             }
             catch (err) {
-                out.failures.push({ path: MEMORY_INDEX_FILENAME, detail: `index sweep failed: ${thrownText(err)}` });
+                out.failures.push({ path: MEMORY_INDEX_FILENAME, detail: `index sweep failed: ${this.writeFailureText(err)}` });
             }
         }
         const scanned = scanEntryFiles(writableRoot, {
@@ -726,6 +950,14 @@ export class MemoryEngine {
         return this.challengeAndAnnounce(ids.map((entryId) => ({ eventId: `${requestId}:${entryId}`, entryId, reason })));
     }
     async eraseMemoryEntries(input) {
+        try {
+            return await this.eraseMemoryEntriesCore(input);
+        }
+        catch (err) {
+            throw withPermissionRemedy(err, this.memoryDir);
+        }
+    }
+    async eraseMemoryEntriesCore(input) {
         const captured = captureErasureInput(input);
         const bad = erasureRequestInvalid(captured);
         if (bad !== undefined) {
@@ -859,6 +1091,7 @@ export class MemoryEngine {
                 if (kept.length === lines.length)
                     continue;
                 try {
+                    this.refuseOutsideStore(landingPathOf(this.memoryDir), indexPath, "rewriting the index");
                     writeFileNoFollow(indexPath, kept.join("\n"));
                 }
                 catch {
@@ -867,7 +1100,7 @@ export class MemoryEngine {
             }
         }
         catch (err) {
-            uncleared.push(`${join(this.memoryDir, "<scope homes>", MEMORY_INDEX_FILENAME)} (index sweep failed: ${thrownText(err)})`);
+            uncleared.push(`${join(this.memoryDir, "<scope homes>", MEMORY_INDEX_FILENAME)} (index sweep failed: ${this.writeFailureText(err)})`);
         }
         if (uncleared.length > 0) {
             try {
@@ -1168,12 +1401,30 @@ export class MemoryEngine {
             adoptRootScopeLayout(this.memoryDir, this.controlDir, { ownerCandidate: writeScope, onIncident: this.onIncident, convertSidecars: convertV1SidecarKeys });
     }
     async materialize(scopes, writeScope, opts) {
+        const legSeat = {};
+        try {
+            return await this.materializeCore(scopes, writeScope, opts, legSeat);
+        }
+        catch (err) {
+            if (legSeat.leg !== undefined && opts?.sessionId !== undefined)
+                this.endLeg(opts.sessionId, legSeat.leg);
+            throw withPermissionRemedy(err, this.memoryDir);
+        }
+    }
+    async materializeCore(scopes, writeScope, opts, legSeat) {
         ensureDirExists(this.memoryDir);
+        const physicalRoot = landingPathOf(this.memoryDir);
+        this.mountedRoot ??= physicalRoot;
+        if (physicalRoot !== this.mountedRoot) {
+            const e = new Error(`${TARGET_OUTSIDE_STORE}: the memory dir ${this.memoryDir} now resolves to ${physicalRoot}, not ${this.mountedRoot} where this engine first mounted it — refused; open a new engine on the directory you mean`);
+            e.code = TARGET_OUTSIDE_STORE;
+            throw e;
+        }
         ensureDirExists(this.controlDir);
         await this.adoptLayoutBeforeMount(writeScope);
-        chmodNoFollow(this.memoryDir, 0o755);
         const restricted = opts?.adoptionRestricted === true;
         let sessionAccountFailed = false;
+        let accountLeg;
         const readBackend = restricted
             ? (this.backend.restrictedAdoptionView?.({ audit: true, writeScope }) ?? this.backend)
             : this.backend;
@@ -1182,9 +1433,13 @@ export class MemoryEngine {
             scopeDirs.set(scope, registerScope(this.memoryDir, this.controlDir, scope));
         if (writeScope !== null && !scopeDirs.has(writeScope))
             scopeDirs.set(writeScope, registerScope(this.memoryDir, this.controlDir, writeScope));
-        const sweepAnnounced = new Set();
         for (const dir of scopeDirs.values())
-            this.chmodScopeTree(dir, 0o755, 0o644, { announced: sweepAnnounced });
+            this.censusScopeTree(dir);
+        const layerBaseline = this.backendPinnedRoot !== undefined && canonicalize(this.backendPinnedRoot) === canonicalize(this.memoryDir)
+            ? readOnlyLayerCensus([...scopeDirs].filter(([scope]) => scope !== writeScope).map(([, dir]) => dir))
+            : undefined;
+        if (layerBaseline !== undefined)
+            this.discloseUnsettleableObservations();
         if (this.provenance === "carry" && opts?.sessionId !== undefined && writeScope !== null && !restricted) {
             let accountFailed = false;
             try {
@@ -1300,10 +1555,19 @@ export class MemoryEngine {
                         }
                     }
                 }
-                openSessionAccount(this.controlDir, { sessionId: opts.sessionId, now: this.now, unattributed });
+                accountLeg = legSeat.leg = uuidv7();
+                openSessionAccount(this.controlDir, { sessionId: opts.sessionId, now: this.now, unattributed, writeScope, leg: accountLeg });
             }
             catch (err) {
                 accountFailed = true;
+                if (accountLeg !== undefined) {
+                    try {
+                        if (sessionAccountLeg(this.controlDir, opts.sessionId) !== accountLeg)
+                            accountLeg = legSeat.leg = undefined;
+                    }
+                    catch {
+                    }
+                }
                 this.discloseSessionAccountIncident("crash-residue attribution is degraded for this session (the harvest boundary refuses fail-closed while this stands)", err);
             }
             if (accountFailed)
@@ -1334,10 +1598,13 @@ export class MemoryEngine {
             ...(opts?.shadowNames !== undefined ? { shadowNames: opts.shadowNames } : {}),
             ...(restricted ? { adoptionRestricted: true } : {}),
             ...(sessionAccountFailed ? { sessionAccountFailed: true } : {}),
+            ...(layerBaseline !== undefined ? { layerBaseline } : {}),
+            ...(accountLeg !== undefined ? { accountLeg } : {}),
         };
         if (handle.writableRoot !== null)
             ensureDirExists(handle.writableRoot);
         const zeroCopy = this.backendPinnedRoot !== undefined && canonicalize(this.backendPinnedRoot) === canonicalize(this.memoryDir);
+        const projectionRoot = zeroCopy ? undefined : this.mountedRoot;
         for (const [scope, dir] of scopeDirs) {
             const scopeEntries = (byScope.get(scope) ?? []).slice();
             scopeEntries.sort((a, b) => (mtimeById.get(b.id) ?? 0) - (mtimeById.get(a.id) ?? 0));
@@ -1359,8 +1626,8 @@ export class MemoryEngine {
                 const { deleted: _stubDrop, ...stubFm } = entry.frontmatter;
                 const text = stub ? serializeEntryFile({ id: entry.id, frontmatter: stubFm, body: STUB_ARCHIVED_LINE }) : fullText;
                 const target = join(dir, `${entry.slug}.md`);
-                if (!(zeroCopy && restricted))
-                    this.writeIfChanged(target, text);
+                if (projectionRoot !== undefined)
+                    this.writeIfChanged(target, text, projectionRoot);
                 const onDiskRev = stub ? revOfText(text, entry.id) : entry.rev;
                 const path = canonicalize(target);
                 handle.materialized.push({
@@ -1444,6 +1711,15 @@ export class MemoryEngine {
             catch {
             }
         }
+        const indexRefusals = materializeHealWarnings.filter((w) => w.startsWith(INDEX_WRITE_REFUSED));
+        if (indexRefusals.length > 0) {
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at: this.now(), items: capItems(indexRefusals.map((w) => inlineUntrusted(w, 500))) });
+            }
+            catch (err) {
+                this.discloseAnnounceFailure("materialize index-write enqueue", err);
+            }
+        }
         if (indexWrite && handle.indexOnDiskUntrusted !== true) {
             const dropNotes = materializeHealWarnings.filter((w) => w.includes("opaque external-origin handle"));
             if (dropNotes.length > 0) {
@@ -1455,16 +1731,20 @@ export class MemoryEngine {
                 }
             }
         }
-        for (const [scope, dir] of scopeDirs) {
-            if (scope === writeScope)
-                continue;
-            this.chmodScopeTree(dir, 0o555, 0o444, {
-                announced: sweepAnnounced,
-            });
-        }
         if (handle.writableRoot !== null) {
             const writableRoot = handle.writableRoot;
             const files = new Map();
+            const refused = new Map();
+            const probeWritable = (p) => {
+                try {
+                    accessSync(p, fsConstants.W_OK);
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT" && !refused.has(p))
+                        refused.set(p, err);
+                }
+            };
+            probeWritable(writableRoot);
             for (const f of scanEntryFiles(writableRoot, { maxDepth: this.maxDepth })) {
                 const canonical = canonicalize(f.path);
                 if (canonical !== writableRoot && !canonical.startsWith(`${writableRoot}${sep}`))
@@ -1472,6 +1752,19 @@ export class MemoryEngine {
                 const text = readSafe(canonical);
                 if (text !== undefined)
                     files.set(canonical, planeDigest(text));
+                probeWritable(dirname(canonical));
+                probeWritable(canonical);
+            }
+            const [firstRefused] = refused;
+            if (firstRefused !== undefined) {
+                const [path, err] = firstRefused;
+                const remedy = permissionRemedyOf(Object.assign(new Error("write refused"), { code: err?.code, path }), this.memoryDir);
+                try {
+                    enqueueMemoryAnnouncement(this.controlDir, { kind: "gate", at: this.now(), items: [inlineUntrusted(`this session's memory write home cannot be written at ${refused.size} path(s) (${path}${refused.size > 1 ? ", …" : ""}): ${remedy ?? thrownText(err)}`, 700)] });
+                }
+                catch (err) {
+                    this.discloseAnnounceFailure("write-home permission enqueue", err);
+                }
             }
             const indexOnDisk = readSafe(join(writableRoot, MEMORY_INDEX_FILENAME));
             handle.planeBaseline = { files, ...(indexOnDisk !== undefined ? { index: indexOnDisk } : {}) };
@@ -1524,14 +1817,17 @@ export class MemoryEngine {
         };
     }
     gateWrite(handle, canonicalPath, content) {
-        const root = handle.writableRoot ?? handle.memoryDir;
-        if (canonicalPath !== root && !canonicalPath.startsWith(`${root}${sep}`))
+        const inside = (root) => canonicalPath === root || canonicalPath.startsWith(`${root}${sep}`);
+        if (!inside(handle.memoryDir))
             return { ok: true };
-        if (handle.writeScope === null) {
+        const root = handle.writableRoot;
+        if (handle.writeScope === null || root === null || !inside(root)) {
             return {
                 ok: false,
                 code: "read_only_layering",
-                reason: "this session's memory is read-only (no write scope) — the engine does not accept writes into the memory domain. Nothing was written.",
+                reason: handle.writeScope === null || root === null
+                    ? "this session's memory is read-only (no write scope) — the engine does not accept writes into the memory domain. Nothing was written."
+                    : `this path is in a read-only inherited memory layer — this session writes memory only under ${root}. Nothing was written.`,
                 muted: false,
             };
         }
@@ -1555,7 +1851,18 @@ export class MemoryEngine {
         return { ok: false, code: f.code, reason, muted };
     }
     async harvest(handle, opts) {
-        const report = await this.harvestCore(handle, opts);
+        const out = {};
+        try {
+            out.report = await this.harvestCore(handle, opts);
+        }
+        catch (err) {
+            throw withPermissionRemedy(err, this.memoryDir);
+        }
+        finally {
+            if (opts?.phase === "terminal" && opts.sessionId !== undefined && this.endSessionLeg(handle, opts.sessionId) === "stale" && out.report !== undefined && !out.report.warnings.includes(STALE_LEG_NOTE))
+                out.report.warnings.push(STALE_LEG_NOTE);
+        }
+        const report = out.report;
         try {
             const named = report.reportId !== undefined ? { reportId: report.reportId } : {};
             const gateItems = gateAnnouncementItems(report);
@@ -1606,7 +1913,16 @@ export class MemoryEngine {
         const writeScope = handle.writeScope;
         const captureRead = opts?.sessionId !== undefined ? await this.sessionCaptureOptOutOrFault(opts.sessionId) : { fault: false };
         const captureOptOut = captureRead.record;
-        if (writeScope === null || opts?.admitNothing !== undefined || captureOptOut !== undefined || captureRead.fault) {
+        const admitsNothing = writeScope === null || opts?.admitNothing !== undefined || captureOptOut !== undefined || captureRead.fault;
+        const readOnlyRestorable = await this.detectReadOnlyLayerChanges(handle, report, admitsNothing);
+        let observed;
+        try {
+            observed = await this.observeReadOnlyLayers(handle, report, opts?.sessionId);
+        }
+        catch (err) {
+            report.warnings.push(`read-only memory layers could not be examined for unexpected writes (nothing was recorded): ${this.writeFailureText(err)}`);
+        }
+        if (admitsNothing) {
             try {
                 this.backend.auditRestrictedDivergence?.([...new Set([...handle.scopes, ...(writeScope !== null ? [writeScope] : [])])], (handle.adoptionRestricted === true || captureOptOut !== undefined) && writeScope !== null ? { idlessWriteScope: writeScope } : undefined);
             }
@@ -1627,9 +1943,10 @@ export class MemoryEngine {
                     }
                 }
                 catch (err) {
-                    report.warnings.push(`capture opt-out boundary sweep failed: ${thrownText(err)} — residue on the writable memory root may await a later session's adoption`);
+                    report.warnings.push(`capture opt-out boundary sweep failed: ${this.writeFailureText(err)} — residue on the writable memory root may await a later session's adoption`);
                 }
             }
+            this.concludeObservations(observed, report);
             if (opts?.admitNothing !== undefined)
                 report.warnings.push(opts.admitNothing.reason);
             else if (captureOptOut !== undefined) {
@@ -1643,6 +1960,7 @@ export class MemoryEngine {
         if (carry && handle.sessionAccountFailed === true) {
             report.ok = false;
             report.incident = { kind: "sidecar_corrupt", detail: "memory session account could not be opened at materialize — the crash-residue classification for this session never persisted, so the harvest refuses fail-closed (repair the control plane and re-materialize)" };
+            this.concludeObservations(observed, report);
             return report;
         }
         try {
@@ -1650,9 +1968,15 @@ export class MemoryEngine {
         }
         catch (err) {
             report.ok = false;
-            report.incident = { kind: "sidecar_corrupt", detail: `memory control plane refused: ${thrownText(err)}` };
+            report.incident = { kind: "sidecar_corrupt", detail: `memory control plane refused: ${this.writeFailureText(err)}` };
+            this.concludeObservations(observed, report);
             return report;
         }
+        if (observed !== undefined && !observed.landed)
+            this.landObservations(observed, report);
+        if (observed !== undefined && !observed.landed)
+            this.concludeObservations(observed, report);
+        await this.settleUndecidedObservations(handle, report, landedUndecided(observed));
         try {
             if (carry) {
                 reconcileHolds(this.controlDir, { homeOf: (scope) => scopeDirFor(this.memoryDir, this.controlDir, scope), now: this.now });
@@ -1834,7 +2158,7 @@ export class MemoryEngine {
                 return true;
             }
             catch (err) {
-                report.warnings.push(`memory index could NOT be restored to its pre-session state: ${thrownText(err)}`);
+                report.warnings.push(`memory index could NOT be restored to its pre-session state: ${this.writeFailureText(err)}`);
                 return false;
             }
         };
@@ -1864,39 +2188,7 @@ export class MemoryEngine {
                 signalContainment((c) => (c.indexRolledBack = true));
             report.warnings.push(`memory harvest refused by an incident while this session is marked externally exposed — no entries were committed; instruction-form files were withheld and the derived index rolled back: ${inlineUntrusted(pollutedReason, 200)}`);
         };
-        for (const m of handle.materialized.filter((x) => x.readonly)) {
-            const text = readSafe(m.path);
-            if (text === undefined) {
-                report.missing.push(m.relPath);
-                continue;
-            }
-            if (revOfText(text, m.id) !== m.rev) {
-                report.rejections.push({ path: m.relPath, code: "readonly_layer", reason: "a read-only inherited memory layer was modified; changes to inherited layers are not writable from this session" });
-                const committed = await this.committedContentFor(m.id);
-                if (committed !== undefined) {
-                    let fd;
-                    try {
-                        fd = openNoFollowForMode(m.path);
-                        if (fd !== undefined)
-                            fchmodSync(fd, 0o644);
-                        writeFileNoFollow(m.path, committed);
-                        report.restored.push(m.relPath);
-                    }
-                    catch {
-                    }
-                    finally {
-                        if (fd !== undefined) {
-                            try {
-                                fchmodSync(fd, 0o444);
-                            }
-                            catch {
-                            }
-                            closeSync(fd);
-                        }
-                    }
-                }
-            }
-        }
+        await this.restoreReadOnlyLayers(readOnlyRestorable, report, handle.accountLeg, handle.memoryDir);
         const missingWritable = writable.filter((m) => !recordByPath.has(m.path) && !existsSync(m.path) && !presentIds.has(m.id));
         report.missing.push(...missingWritable.map((m) => m.relPath));
         if (writable.length > 0 && missingWritable.length / writable.length > MASS_DELETION_FUSE_RATIO) {
@@ -1923,11 +2215,13 @@ export class MemoryEngine {
             if (content === undefined)
                 continue;
             try {
+                this.refuseOutsideStore(handle.memoryDir, m.path, "restoring");
                 mkdirSync(dirname(m.path), { recursive: true });
                 writeFileNoFollow(m.path, content);
                 report.restored.push(m.relPath);
             }
-            catch {
+            catch (err) {
+                report.warnings.push(`${m.relPath}: the committed copy of this missing memory file could NOT be restored: ${this.writeFailureText(err)}`);
             }
         }
         const baselinePaths = new Set(writable.map((m) => m.path));
@@ -1964,6 +2258,8 @@ export class MemoryEngine {
         const pendingProjections = [];
         const idsAddedThisHarvest = new Set();
         const modelIdAdds = new Set();
+        const stoodAsFound = new Set();
+        let observedTable;
         let processed = 0;
         for (let i = 0; i < kept.length; i++) {
             const f = kept[i];
@@ -1980,10 +2276,14 @@ export class MemoryEngine {
                 continue;
             }
             const fastBaseId = idByBasePath.get(f.canonical);
+            if (fastBaseId !== undefined && !stubByPath.has(f.canonical) && revOfText(f.text, fastBaseId) !== revByBasePath.get(f.canonical) && handle.planeBaseline?.files.get(f.canonical) === planeDigest(f.text)) {
+                stoodAsFound.add(rel);
+                continue;
+            }
             if (fastBaseId !== undefined && !stubByPath.has(f.canonical) && revOfText(f.text, fastBaseId) === revByBasePath.get(f.canonical)) {
                 const fastDebt = projectionDebts.get(debtSeat(writeScope, homeRel(writableRoot, f.canonical)));
                 if (fastDebt !== undefined && fastDebt.entryId === fastBaseId)
-                    await this.repairProjectionSeat(seatOf(f.canonical), f.canonical, fastBaseId, debtClears);
+                    await this.repairProjectionSeat(seatOf(f.canonical), f.canonical, fastBaseId, debtClears, report.warnings);
                 continue;
             }
             processed++;
@@ -2043,6 +2343,21 @@ export class MemoryEngine {
             const parsed = f.parsed;
             let baseId = idByBasePath.get(f.canonical);
             let id = baseId ?? parsed.id;
+            if (baseId === undefined && handle.planeBaseline?.files.get(f.canonical) === planeDigest(f.text)) {
+                const observed = (observedTable ??= layerObservationLookup(this.controlDir));
+                const committedRow = parsed.id !== undefined && observed.covers(parsed.id) ? await this.committedRowOf(parsed.id) : undefined;
+                if (committedRow === "undecidable") {
+                    report.rejections.push({ path: rel, code: "deferred", reason: "memory write deferred: this file's id is named by the read-only-layer observation table and the committed account could not be read whole — retried next harvest" });
+                    continue;
+                }
+                const recorded = parsed.id === undefined
+                    ? observed.findNote(writeScope, homeRel(writableRoot, f.canonical), planeDigest(f.text)) !== undefined
+                    : observed.covers(parsed.id) && observed.find(parsed.id, committedRow?.rev, revOfText(f.text, parsed.id)) !== undefined;
+                if (recorded) {
+                    report.rejections.push({ path: rel, code: "readonly_layer", reason: "this file appeared while a session held this memory layer read-only (recorded as an unexpected write) — it is not committed as this session's; remove it, or edit it to commit this session's own version" });
+                    continue;
+                }
+            }
             let debtReconciled = false;
             if (id === undefined && projectionDebts.size > 0) {
                 const debt = projectionDebts.get(debtSeat(writeScope, homeRel(writableRoot, f.canonical)));
@@ -2129,7 +2444,7 @@ export class MemoryEngine {
                                 report.restored.push(rel);
                             }
                             catch (err) {
-                                report.warnings.push(`${rel}: the committed content could not be restored after the hold captured this session's edit — the entry is unavailable on the plane until release or the next restore: ${thrownText(err)}`);
+                                report.warnings.push(`${rel}: the committed content could not be restored after the hold captured this session's edit — the entry is unavailable on the plane until release or the next restore: ${this.writeFailureText(err)}`);
                             }
                         }
                     }
@@ -2176,7 +2491,7 @@ export class MemoryEngine {
                 if (revOfText(f.text, id) === revByBasePath.get(f.canonical)) {
                     const seatDebt = projectionDebts.get(debtSeat(writeScope, homeRel(writableRoot, f.canonical)));
                     if (seatDebt !== undefined && seatDebt.entryId === id)
-                        await this.repairProjectionSeat(seatOf(f.canonical), f.canonical, id, debtClears);
+                        await this.repairProjectionSeat(seatOf(f.canonical), f.canonical, id, debtClears, report.warnings);
                     continue;
                 }
                 pendingProjections.push({ path: f.canonical, entry, needed: minted || parsed.id !== id || needsCompletion(parsed, fm), ...(debtReconciled ? { idCompletion: true } : {}) });
@@ -2200,7 +2515,7 @@ export class MemoryEngine {
                     report.rejections.push({
                         path: rel,
                         code: "filename",
-                        reason: `memory write blocked: this file carries the entry id of another memory file (a copy is not a rename) and its frontmatter could not be rewritten (${thrownText(err)}) — remove the "id:" line so it can be committed as a new entry`,
+                        reason: `memory write blocked: this file carries the entry id of another memory file (a copy is not a rename) and its frontmatter could not be rewritten (${this.writeFailureText(err)}) — remove the "id:" line so it can be committed as a new entry`,
                     });
                     continue;
                 }
@@ -2219,7 +2534,7 @@ export class MemoryEngine {
                     report.rejections.push({
                         path: rel,
                         code: "filename",
-                        reason: `memory write blocked: an external-origin commit does not adopt the file's model-written entry id and its frontmatter could not be rewritten (${thrownText(err)}) — remove the "id:" line so it can be committed under an engine-minted id`,
+                        reason: `memory write blocked: an external-origin commit does not adopt the file's model-written entry id and its frontmatter could not be rewritten (${this.writeFailureText(err)}) — remove the "id:" line so it can be committed under an engine-minted id`,
                     });
                     continue;
                 }
@@ -2341,7 +2656,7 @@ export class MemoryEngine {
                                     report.rejections.push({
                                         path: flipRec.rel,
                                         code: "filename",
-                                        reason: `memory write blocked: an external-origin commit does not adopt the file's model-written entry id and its frontmatter could not be rewritten (${thrownText(err)}) — remove the "id:" line so it can be committed under an engine-minted id`,
+                                        reason: `memory write blocked: an external-origin commit does not adopt the file's model-written entry id and its frontmatter could not be rewritten (${this.writeFailureText(err)}) — remove the "id:" line so it can be committed under an engine-minted id`,
                                     });
                                     droppedIds.add(p.id);
                                     continue;
@@ -2458,7 +2773,7 @@ export class MemoryEngine {
                         }
                     }
                     report.ok = false;
-                    report.incident = { kind: "sidecar_corrupt", detail: `memory commit refused: ${thrownText(err)}` };
+                    report.incident = { kind: "sidecar_corrupt", detail: `memory commit refused: ${this.writeFailureText(err)}` };
                     return report;
                 }
                 if (lineageArmed) {
@@ -2514,18 +2829,25 @@ export class MemoryEngine {
             }
         }
         const appliedIds = new Set(patchReport.applied.filter((a) => a.op !== "delete").map((a) => a.id));
+        const planeAfterFailedWriteBack = this.backendPinnedRoot !== undefined && canonicalize(this.backendPinnedRoot) === canonicalize(this.memoryDir)
+            ? "this plane is the store itself: the next read adopts them as an out-of-session edit unless the committed copy is put back first"
+            : "the next materialize re-projects the committed copy over them";
         for (const p of pendingProjections) {
             const pRel = relative(handle.memoryDir, p.path);
             const pSeat = seatOf(p.path);
             if (appliedIds.has(p.entry.id)) {
-                const wrote = this.writeBackProjection(p.path, p.entry, p.needed);
-                if (p.idCompletion === true) {
-                    if (wrote)
+                const writeBackFailure = this.writeBackProjection(p.path, p.entry, p.needed);
+                if (p.idCompletion !== true) {
+                    if (writeBackFailure !== undefined)
+                        report.warnings.push(`${pRel}: the entry committed but its projection write-back FAILED — the plane keeps this session's bytes (${planeAfterFailedWriteBack}): ${writeBackFailure}`);
+                }
+                else {
+                    if (writeBackFailure === undefined)
                         debtClears.push({ ...pSeat, entryId: p.entry.id });
                     else {
                         const landed = patchReport.applied.find((a) => a.id === p.entry.id)?.slug;
                         const suffixNote = landed !== undefined && landed !== p.entry.slug ? ` NOTE: the entry landed at slug ${JSON.stringify(landed)} (collision suffix) — the seat claim will not re-bind; host reconciliation may be needed.` : "";
-                        report.warnings.push(`${pRel}: the entry committed but its id write-back FAILED — the projection-debt row stands, so the file re-binds to its committed id at the next harvest (and the next materialize repairs the plane); it is never re-admitted as a duplicate.${suffixNote}`);
+                        report.warnings.push(`${pRel}: the entry committed but its id write-back FAILED — the projection-debt row stands, so the file re-binds to its committed id at the next harvest (and the next materialize repairs the plane); it is never re-admitted as a duplicate.${suffixNote} Cause: ${writeBackFailure}`);
                     }
                 }
                 continue;
@@ -2538,7 +2860,8 @@ export class MemoryEngine {
                     writeFileNoFollow(p.path, committed);
                     planeHoldsCommitted = true;
                 }
-                catch {
+                catch (err) {
+                    report.warnings.push(`${pRel}: this session's version lost to a concurrent commit and the committed copy could NOT be written back over it — the plane keeps this session's bytes (${planeAfterFailedWriteBack}): ${this.writeFailureText(err)}`);
                 }
             }
             else if (committed !== undefined) {
@@ -2587,15 +2910,17 @@ export class MemoryEngine {
         }
         const headers = await this.backend.listHeaders([...new Set([...handle.scopes, writeScope])]);
         handle.indexText = this.rebuildIndex(handle, headers, { write: true, ignoreOnDisk: indexGate !== undefined }, report.warnings);
-        await this.rebaseline(handle, new Set(report.degraded?.pending ?? []), new Set(report.rejections.map((r) => r.path)));
+        await this.rebaseline(handle, new Set([...(report.degraded?.pending ?? []), ...stoodAsFound]), new Set(report.rejections.map((r) => r.path)));
         if (carry && lineageSessionId !== undefined && report.degraded === undefined) {
             const deferredSeats = [...new Set(report.rejections.filter((r) => r.code === "deferred").map((r) => r.path))];
             const shown = deferredSeats.slice(0, MAX_DISCLOSED_DEFERRED_SEATS);
             const rest = deferredSeats.length - shown.length;
             const seatList = `${shown.join(", ")}${rest > 0 ? ` (+${rest} more — see the rejections)` : ""}`;
             try {
-                const closed = closeSessionAccount(this.controlDir, { sessionId: lineageSessionId, now: this.now });
-                if (closed && deferredSeats.length > 0) {
+                const closed = handle.accountLeg !== undefined ? closeSessionAccount(this.controlDir, { sessionId: lineageSessionId, now: this.now, leg: handle.accountLeg }) : "absent";
+                if (closed === "stale" && !report.warnings.includes(STALE_LEG_NOTE))
+                    report.warnings.push(STALE_LEG_NOTE);
+                if (closed === "written" && deferredSeats.length > 0) {
                     report.warnings.push(`memory session account closed with ${deferredSeats.length} file(s) still DEFERRED on the model-visible plane — their projection-debt rows STAND and are re-judged by the next harvest's consult, not by this close: ${seatList}`);
                 }
             }
@@ -4288,6 +4613,8 @@ export class MemoryEngine {
             const id = parsed.id ?? handle.baseIds.get(path);
             if (id === undefined)
                 continue;
+            if (uncommitted && handle.baseIds.get(path) === undefined)
+                continue;
             const stub = stubs.get(path);
             const priorRev = deferred ? handle.baseRevs.get(path) : undefined;
             const priorId = deferred ? handle.baseIds.get(path) : undefined;
@@ -4504,13 +4831,15 @@ export class MemoryEngine {
         if (opts.write) {
             let wrote = false;
             try {
+                this.refuseOutsideStore(handle.memoryDir, indexPath, "writing the index");
                 mkdirSync(dirname(indexPath), { recursive: true });
                 if (readNoFollowSafe(indexPath) !== text)
                     writeFileNoFollow(indexPath, text);
                 wrote = true;
             }
-            catch {
+            catch (err) {
                 handle.indexOnDiskUntrusted = true;
+                warnings?.push(`${INDEX_WRITE_REFUSED}: ${this.writeFailureText(err)}`);
             }
             if (wrote)
                 writeIndexRevs(this.controlDir, nextIndexRevs);
@@ -4593,11 +4922,12 @@ export class MemoryEngine {
         }
         let cleared = false;
         try {
+            this.refuseOutsideStore(handle.memoryDir, indexPath, "clearing the index");
             writeFileNoFollow(indexPath, "");
             cleared = true;
         }
         catch (err) {
-            detail = `${detail}; the derived index could NOT be cleared: ${thrownText(err)}`;
+            detail = `${detail}; the derived index could NOT be cleared: ${this.writeFailureText(err)}`;
         }
         const outcome = [
             captured ? "the offending prose was captured to quarantine" : "the quarantine capture FAILED — the prose was not preserved",
@@ -4612,7 +4942,16 @@ export class MemoryEngine {
             contained: cleared,
         };
     }
-    writeIfChanged(target, text) {
+    refuseOutsideStore(root, path, act) {
+        const escape = storeTargetEscape(root, path);
+        if (escape === undefined)
+            return;
+        const e = new Error(`${TARGET_OUTSIDE_STORE}: ${act} ${path} was refused — ${escape}; not performed`);
+        e.code = TARGET_OUTSIDE_STORE;
+        throw e;
+    }
+    writeIfChanged(target, text, root) {
+        this.refuseOutsideStore(root, target, "the projection write of");
         const current = readNoFollowSafe(target);
         if (current === text)
             return;
@@ -4621,19 +4960,19 @@ export class MemoryEngine {
     }
     writeBackProjection(path, entry, needed) {
         if (!needed)
-            return true;
+            return undefined;
         const text = serializeEntryFile(entry);
         if (readNoFollowSafe(path) === text)
-            return true;
+            return undefined;
         try {
             writeFileNoFollow(path, text);
-            return true;
+            return undefined;
         }
-        catch {
-            return false;
+        catch (err) {
+            return this.writeFailureText(err);
         }
     }
-    async repairProjectionSeat(seat, canonical, entryId, debtClears) {
+    async repairProjectionSeat(seat, canonical, entryId, debtClears, warnings) {
         const committed = await this.committedContentFor(entryId);
         if (committed === undefined)
             return;
@@ -4641,7 +4980,8 @@ export class MemoryEngine {
             try {
                 writeFileNoFollow(canonical, committed);
             }
-            catch {
+            catch (err) {
+                warnings.push(`${relative(this.memoryDir, canonical)}: the committed copy could NOT be written over this id-less seat — the projection-debt row stands and the repair retries next pass: ${this.writeFailureText(err)}`);
                 return;
             }
         }
@@ -4662,18 +5002,18 @@ export class MemoryEngine {
             return { state: "unknown" };
         }
     }
-    chmodScopeTree(dir, dirMode, fileMode, opts = {}) {
+    censusScopeTree(dir) {
         if (!existsSync(dir))
             return;
-        const sweepSkipped = [];
-        const sweptLinks = [];
+        const unreadable = [];
+        const links = [];
         const walk = (d) => {
             let names = [];
             try {
                 names = readdirSync(d);
             }
             catch {
-                sweepSkipped.push(d);
+                unreadable.push(d);
                 return;
             }
             for (const name of names) {
@@ -4683,50 +5023,34 @@ export class MemoryEngine {
                     st = lstatSync(p);
                 }
                 catch {
-                    sweepSkipped.push(p);
+                    unreadable.push(p);
                     continue;
                 }
-                if (st.isSymbolicLink()) {
-                    sweptLinks.push(p);
-                    continue;
-                }
-                if (st.isDirectory())
+                if (st.isSymbolicLink())
+                    links.push(p);
+                else if (st.isDirectory())
                     walk(p);
-                else if (st.isFile() && name.endsWith(".md") && name !== MEMORY_INDEX_FILENAME)
-                    chmodNoFollow(p, fileMode);
             }
-            chmodNoFollow(d, dirMode);
         };
         walk(dir);
-        const said = opts.announced;
-        const anomalyKey = (kind, path) => JSON.stringify([kind, path]);
-        const unsaid = (paths, kind) => (said === undefined ? paths : paths.filter((p) => !said.has(anomalyKey(kind, p))));
-        const skipped = unsaid(sweepSkipped, "unreadable");
-        const links = unsaid(sweptLinks, "symlink");
-        if (skipped.length + links.length > 0) {
-            try {
-                enqueueMemoryAnnouncement(this.controlDir, {
-                    kind: "gate",
-                    at: this.now(),
-                    items: skipped
-                        .slice(0, 12)
-                        .map((p) => `mode sweep could not read ${JSON.stringify(inlineUntrusted(relative(dir, p) || "."))} — files under it keep their previous mode`)
-                        .concat(skipped.length > 12 ? [`…and ${skipped.length - 12} more sweepSkipped path(s)`] : [])
-                        .concat(links
-                        .slice(0, 12)
-                        .map((p) => `mode sweep skipped the symlink ${JSON.stringify(inlineUntrusted(relative(dir, p) || "."))} — links are not part of a memory scope tree and are never followed`))
-                        .concat(links.length > 12 ? [`…and ${links.length - 12} more skipped symlink(s)`] : []),
-                });
-                if (said !== undefined) {
-                    for (const p of skipped)
-                        said.add(anomalyKey("unreadable", p));
-                    for (const p of links)
-                        said.add(anomalyKey("symlink", p));
-                }
-            }
-            catch (err) {
-                this.discloseAnnounceFailure("mode-sweep enqueue", err);
-            }
+        if (unreadable.length + links.length === 0)
+            return;
+        try {
+            enqueueMemoryAnnouncement(this.controlDir, {
+                kind: "gate",
+                at: this.now(),
+                items: unreadable
+                    .slice(0, 12)
+                    .map((p) => `layer census could not read ${JSON.stringify(inlineUntrusted(relative(dir, p) || "."))} — nothing under it was examined`)
+                    .concat(unreadable.length > 12 ? [`…and ${unreadable.length - 12} more unreadable path(s)`] : [])
+                    .concat(links
+                    .slice(0, 12)
+                    .map((p) => `layer census skipped the symlink ${JSON.stringify(inlineUntrusted(relative(dir, p) || "."))} — links are not part of a memory scope tree and are never followed`))
+                    .concat(links.length > 12 ? [`…and ${links.length - 12} more skipped symlink(s)`] : []),
+            });
+        }
+        catch (err) {
+            this.discloseAnnounceFailure("layer-census enqueue", err);
         }
     }
 }
@@ -4813,16 +5137,6 @@ function readSafe(path) {
         return undefined;
     }
 }
-function openNoFollowForMode(path) {
-    for (const flags of [fsConstants.O_RDONLY, fsConstants.O_WRONLY]) {
-        try {
-            return openSync(path, flags | fsConstants.O_NOFOLLOW);
-        }
-        catch {
-        }
-    }
-    return undefined;
-}
 function readNoFollowSafe(path) {
     let fd;
     try {
@@ -4837,19 +5151,6 @@ function readNoFollowSafe(path) {
             closeSync(fd);
     }
 }
-function chmodNoFollow(path, mode) {
-    const fd = openNoFollowForMode(path);
-    if (fd === undefined)
-        return;
-    try {
-        fchmodSync(fd, mode);
-    }
-    catch {
-    }
-    finally {
-        closeSync(fd);
-    }
-}
 function needsCompletion(parsed, fm) {
     return (!parsed.hadFrontmatter ||
         parsed.frontmatter.name !== fm.name ||