@sema-agent/core 7.14.0 → 7.16.0

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

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { existsSync, linkSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { QUARANTINE_DIR, appendChallengeEvents, enqueueMemoryAnnouncement, ensureDirExists, lineageContributionsOfSession, lockedStrictUpdate, markSessionPolluted, readSessionPollution, readStrictSidecar, ControlPlaneCorruptError } from "./layout.js";
+import { QUARANTINE_DIR, appendChallengeEvents, enqueueMemoryAnnouncement, ensureDirExists, v1MemoryPathKeyResolver, lineageContributionsOfSession, lockedStrictUpdate, markSessionPolluted, readProjectionDebts, readSessionPollution, readStrictSidecar, ControlPlaneCorruptError } from "./layout.js";
 export const DELEGATION_SETTLEMENT_FILE = "delegation-settlement.json";
 function reqStr(v) {
     return typeof v === "string" && v.length > 0;
@@ -233,36 +233,101 @@ export function replayExternalSettlementEffects(controlDir, input) {
     return applied;
 }
 export const SESSION_ACCOUNTS_FILE = "session-accounts.json";
+function malformedAccountRow(row) {
+    return (typeof row !== "object" ||
+        row === null ||
+        !reqStr(row.sessionId) ||
+        typeof row.openedAt !== "number" ||
+        !Number.isFinite(row.openedAt) ||
+        !Array.isArray(row.unattributed) ||
+        (row.closedAt !== undefined && (typeof row.closedAt !== "number" || !Number.isFinite(row.closedAt))) ||
+        (row.unadjudicated !== undefined && row.unadjudicated !== true));
+}
+function isUnattributedMember(x) {
+    return typeof x === "object" && x !== null && reqStr(x.scope) && safeRelPath(x.rel);
+}
 function coerceSessionAccounts(raw) {
     if (raw === undefined)
-        return { version: 1, rows: [] };
+        return { version: 2, rows: [] };
     const rec = raw;
     if (typeof rec !== "object" || rec === null || !Array.isArray(rec.rows))
         throw new ControlPlaneCorruptError("memory session-account ledger has the wrong shape");
-    if (rec.version !== 1)
+    if (rec.version !== 1 && rec.version !== 2)
         throw new ControlPlaneCorruptError(`memory session-account ledger has an unrecognized version (${String(rec.version)}) — refusing (fail-closed)`);
-    for (const r of rec.rows) {
+    const bad = () => {
+        throw new ControlPlaneCorruptError("memory session-account ledger: a row is malformed — refusing (fail-closed; an unevaluable row must not read as adjudicated)");
+    };
+    const rows = rec.rows;
+    for (const r of rows) {
         const row = r;
-        if (typeof row !== "object" ||
-            row === null ||
-            !reqStr(row.sessionId) ||
-            typeof row.openedAt !== "number" ||
-            !Number.isFinite(row.openedAt) ||
-            !Array.isArray(row.unattributed) ||
-            row.unattributed.some((x) => typeof x !== "string") ||
-            (row.closedAt !== undefined && (typeof row.closedAt !== "number" || !Number.isFinite(row.closedAt))) ||
-            (row.unadjudicated !== undefined && row.unadjudicated !== true)) {
-            throw new ControlPlaneCorruptError("memory session-account ledger: a row is malformed — refusing (fail-closed; an unevaluable row must not read as adjudicated)");
+        if (malformedAccountRow(row))
+            bad();
+        const members = Array.isArray(row.unattributed) ? row.unattributed : bad();
+        if (rec.version === 1) {
+            if (members.some((x) => typeof x !== "string"))
+                bad();
         }
-    }
-    return rec;
+        else {
+            if (!members.every(isUnattributedMember))
+                bad();
+            if (row.unattributable !== undefined && (!Array.isArray(row.unattributable) || row.unattributable.some((x) => typeof x !== "string")))
+                bad();
+        }
+    }
+    return rec.version === 1 ? { version: 1, rows: rows } : { version: 2, rows: rows };
+}
+function convertSessionAccounts(read, controlDir) {
+    if (read.version === 2)
+        return { rec: read, converted: false };
+    const resolve = v1MemoryPathKeyResolver(controlDir);
+    const rows = read.rows.map((r) => {
+        const unattributed = [];
+        const unattributable = [];
+        for (const relPath of r.unattributed) {
+            const key = resolve(relPath);
+            if (key === undefined)
+                unattributable.push(relPath);
+            else
+                unattributed.push(key);
+        }
+        return {
+            sessionId: r.sessionId,
+            openedAt: r.openedAt,
+            unattributed,
+            ...(unattributable.length > 0 ? { unattributable } : {}),
+            ...(r.closedAt !== undefined ? { closedAt: r.closedAt } : {}),
+            ...(r.unadjudicated !== undefined ? { unadjudicated: r.unadjudicated } : {}),
+        };
+    });
+    return { rec: { version: 2, rows }, converted: true };
+}
+export function convertV1SidecarKeys(controlDir) {
+    readProjectionDebts(controlDir);
+    readHolds(controlDir);
+    readSessionAccountsConverted(controlDir);
+}
+function readSessionAccountsConverted(controlDir) {
+    const read = coerceSessionAccounts(readStrictSidecar(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger"));
+    if (read.version === 2)
+        return read;
+    return lockedStrictUpdate(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger", coerceSessionAccounts, (again) => {
+        const { rec, converted } = convertSessionAccounts(again, controlDir);
+        return converted ? { next: rec, result: rec } : { result: rec };
+    });
 }
 export function foreignDanglingSessionAccounts(controlDir, selfSessionId) {
-    const rec = coerceSessionAccounts(readStrictSidecar(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger"));
+    const rec = readSessionAccountsConverted(controlDir);
     return rec.rows.filter((r) => r.sessionId !== selfSessionId && (r.closedAt === undefined || r.unadjudicated === true));
 }
+export function emptyUnattributedSet() {
+    return { has: () => false, empty: true };
+}
+function memberKey(scope, rel) {
+    return JSON.stringify([scope, rel]);
+}
 export function openSessionAccount(controlDir, input) {
-    lockedStrictUpdate(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger", coerceSessionAccounts, (rec) => {
+    lockedStrictUpdate(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger", coerceSessionAccounts, (read) => {
+        const { rec } = convertSessionAccounts(read, controlDir);
         const row = rec.rows.find((r) => r.sessionId === input.sessionId);
         if (row === undefined) {
             rec.rows.push({ sessionId: input.sessionId, openedAt: input.now(), unattributed: [...input.unattributed] });
@@ -276,17 +341,25 @@ export function openSessionAccount(controlDir, input) {
             row.openedAt = input.now();
             delete row.closedAt;
             delete row.unadjudicated;
-            row.unattributed = [...new Set([...row.unattributed, ...input.unattributed])];
+            const merged = new Map(row.unattributed.map((m) => [memberKey(m.scope, m.rel), m]));
+            for (const m of input.unattributed)
+                merged.set(memberKey(m.scope, m.rel), { scope: m.scope, rel: m.rel });
+            row.unattributed = [...merged.values()];
         }
         return { next: rec, result: undefined };
     });
 }
 export function sessionUnattributedSet(controlDir, sessionId) {
-    const rec = coerceSessionAccounts(readStrictSidecar(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger"));
-    return new Set(rec.rows.find((r) => r.sessionId === sessionId)?.unattributed ?? []);
+    const row = readSessionAccountsConverted(controlDir).rows.find((r) => r.sessionId === sessionId);
+    if (row === undefined)
+        return emptyUnattributedSet();
+    const all = (row.unattributable?.length ?? 0) > 0;
+    const keys = new Set(row.unattributed.map((m) => memberKey(m.scope, m.rel)));
+    return { has: (scope, rel) => all || keys.has(memberKey(scope, rel.split("\\").join("/"))), empty: !all && keys.size === 0 };
 }
 export function closeSessionAccount(controlDir, input) {
-    return lockedStrictUpdate(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger", coerceSessionAccounts, (rec) => {
+    return lockedStrictUpdate(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger", coerceSessionAccounts, (read) => {
+        const { rec } = convertSessionAccounts(read, controlDir);
         const row = rec.rows.find((r) => r.sessionId === input.sessionId);
         if (row === undefined)
             return { result: false };
@@ -303,7 +376,8 @@ export function resolveSessionAccountRecord(controlDir, input) {
         e.code = "memory.session_account_resolve_unattributed";
         throw e;
     }
-    lockedStrictUpdate(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger", coerceSessionAccounts, (rec) => {
+    lockedStrictUpdate(controlDir, SESSION_ACCOUNTS_FILE, "memory session-account ledger", coerceSessionAccounts, (read) => {
+        const { rec } = convertSessionAccounts(read, controlDir);
         const row = rec.rows.find((r) => r.sessionId === input.sessionId);
         if (row === undefined) {
             const e = new Error(`resolveSessionAccount: unknown sessionId ${JSON.stringify(input.sessionId)}`);
@@ -321,21 +395,23 @@ const HOLD_STATUSES = new Set(["capturing", "held", "released", "disposed"]);
 const HOLD_TERMINALS = new Set(["dirty", "expired", "conflict", "discarded", "capture_lost"]);
 function coerceHolds(raw) {
     if (raw === undefined)
-        return { version: 1, rows: [] };
+        return { version: 2, rows: [] };
     const rec = raw;
     if (typeof rec !== "object" || rec === null || !Array.isArray(rec.rows))
         throw new ControlPlaneCorruptError("memory instruction-hold ledger has the wrong shape");
-    if (rec.version !== 1)
+    if (rec.version !== 1 && rec.version !== 2)
         throw new ControlPlaneCorruptError(`memory instruction-hold ledger has an unrecognized version (${String(rec.version)}) — refusing (fail-closed)`);
-    for (const r of rec.rows) {
+    const v1 = rec.version === 1;
+    const rows = [];
+    const raws = rec.rows;
+    for (const r of raws) {
         const row = r;
         if (typeof row !== "object" ||
             row === null ||
             !reqStr(row.holdId) ||
             !reqStr(row.sessionId) ||
             (row.op !== "add" && row.op !== "update") ||
-            !reqStr(row.relPath) ||
-            !reqStr(row.slug) ||
+            !safeRelPath(row.slug) ||
             !reqStr(row.scope) ||
             !reqStr(row.captureName) ||
             !reqStr(row.contentDigest) ||
@@ -350,15 +426,28 @@ function coerceHolds(raw) {
             (row.entryId !== undefined && typeof row.entryId !== "string") ||
             (row.baseRev !== undefined && typeof row.baseRev !== "string") ||
             (row.op === "update" && (!reqStr(row.entryId) || !reqStr(row.baseRev))) ||
-            !safeRelPath(row.relPath) ||
+            (v1 ? !safeRelPath(row.relPath) : !safeRelPath(row.rel)) ||
             !safeBasename(row.captureName)) {
             throw new ControlPlaneCorruptError("memory instruction-hold ledger: a row is malformed — refusing (fail-closed; an unevaluable hold must not read as settled)");
         }
+        if (v1) {
+            const { relPath: _relPath, ...rest } = row;
+            rows.push({ ...rest, rel: `${row.slug}.md` });
+        }
+        else {
+            rows.push(row);
+        }
     }
-    return rec;
+    return { version: 2, rows };
+}
+function holdsOnDiskAreV1(raw) {
+    return typeof raw === "object" && raw !== null && raw.version === 1;
 }
 export function readHolds(controlDir) {
-    return coerceHolds(readStrictSidecar(controlDir, HOLDS_FILE, "memory instruction-hold ledger")).rows;
+    const raw = readStrictSidecar(controlDir, HOLDS_FILE, "memory instruction-hold ledger");
+    if (!holdsOnDiskAreV1(raw))
+        return coerceHolds(raw).rows;
+    return lockedStrictUpdate(controlDir, HOLDS_FILE, "memory instruction-hold ledger", coerceHolds, (again) => ({ next: again, result: again.rows }));
 }
 function sha256(buf) {
     return createHash("sha256").update(buf).digest("hex");
@@ -397,7 +486,7 @@ export function noReplaceRestore(stagingPath, destPath) {
     return "restored";
 }
 export function openInstructionHold(controlDir, input) {
-    const holdId = `hold-${input.now()}-${createHash("sha256").update(`${input.sessionId}\n${input.relPath}\n${input.content}`).digest("hex").slice(0, 12)}`;
+    const holdId = `hold-${input.now()}-${createHash("sha256").update(`${input.sessionId}\n${input.rel}\n${input.content}`).digest("hex").slice(0, 12)}`;
     const buf = Buffer.from(input.content, "utf8");
     const digest = sha256(buf);
     const captureName = `${holdId}.md`;
@@ -420,7 +509,7 @@ export function openInstructionHold(controlDir, input) {
                 ...(input.entryId !== undefined ? { entryId: input.entryId } : {}),
                 op: input.op,
                 ...(input.baseRev !== undefined ? { baseRev: input.baseRev } : {}),
-                relPath: input.relPath,
+                rel: input.rel,
                 slug: input.slug,
                 scope: input.scope,
                 captureName,
@@ -490,12 +579,12 @@ export function openInstructionHold(controlDir, input) {
 }
 export function reconcileHolds(controlDir, input) {
     const holdDir = join(controlDir, HOLD_DIR);
-    const discloseStranded = (holdId, relPath, stagingName) => {
+    const discloseStranded = (holdId, rel, stagingName) => {
         try {
             enqueueMemoryAnnouncement(controlDir, {
                 kind: "gate",
                 at: input.now(),
-                items: [`instruction hold ${holdId}: a concurrent writer's bytes for ${JSON.stringify(relPath)} could not be restored onto the plane — they are preserved at hold/${stagingName} in the memory control plane for host recovery`],
+                items: [`instruction hold ${holdId}: a concurrent writer's bytes for ${JSON.stringify(rel)} could not be restored onto the plane — they are preserved at hold/${stagingName} in the memory control plane for host recovery`],
             });
         }
         catch {
@@ -512,7 +601,7 @@ export function reconcileHolds(controlDir, input) {
                 terminalLost = true;
             }
             else {
-                const plane = join(input.memoryDir, row.relPath);
+                const plane = join(input.homeOf(row.scope), row.rel);
                 if (existsSync(plane)) {
                     try {
                         const stagingName = uniqueStagingName(row.holdId, input.now);
@@ -522,7 +611,7 @@ export function reconcileHolds(controlDir, input) {
                             unlinkSync(staging);
                         }
                         else if (noReplaceRestore(staging, plane) === "stranded") {
-                            discloseStranded(row.holdId, row.relPath, stagingName);
+                            discloseStranded(row.holdId, row.rel, stagingName);
                         }
                     }
                     catch {
@@ -531,7 +620,7 @@ export function reconcileHolds(controlDir, input) {
             }
         }
         else {
-            const plane = join(input.memoryDir, row.relPath);
+            const plane = join(input.homeOf(row.scope), row.rel);
             if (existsSync(plane)) {
                 const bytes = readFileSync(plane);
                 if (sha256(bytes) === row.contentDigest) {
@@ -549,7 +638,7 @@ export function reconcileHolds(controlDir, input) {
                             }
                         }
                         else if (noReplaceRestore(staging, plane) === "stranded") {
-                            discloseStranded(row.holdId, row.relPath, stagingName);
+                            discloseStranded(row.holdId, row.rel, stagingName);
                         }
                     }
                     catch {

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

@@ -1186,6 +1186,10 @@ export declare class MemoryEngine {
      *  eventId anchors on the pollution record (sessionId + marked-at), so however many times this
      *  settlement replays the same pollution event, the generation is allocated once. */
     private settlePromotions;
+    /** The layout-adoption seat of a mount: a backend pinning its own directory root adopts under its
+     *  transaction lock; a copy-out projection tree and a backend without the face are adopted by the
+     *  engine directly (registry lock only — nothing else writes those trees during a mount). */
+    private adoptLayoutBeforeMount;
     materialize(scopes: readonly string[], writeScope: string | null, opts?: {
         adoptionRestricted?: boolean;
         sessionId?: string;
@@ -1242,6 +1246,9 @@ export declare class MemoryEngine {
      * Throws only on a corrupt hold/settlement ledger — the caller's fail-closed reconciliation arm
      * refuses the harvest (integrity unknown must not read as "no holds").
      */
+    /** A hold's plane seat as a memory-dir-relative path (the report/warning spelling every other
+     *  harvest path uses), derived from the ledger-form row. */
+    private holdPlaneRel;
     private settleDueHolds;
     /**
      * The release leg: re-walk the captured bytes through the FULL gate set and commit them under
@@ -1663,8 +1670,6 @@ export declare class MemoryEngine {
      * @returns the rejection to report, or `undefined` when the index is clean/absent.
      */
     private gateDerivedIndex;
-    /** Names of read-only sibling scope dirs directly under the writable root (excluded from scans; public since #691 — the runner refuses to admit a writable root that contains another scope's directory to the file tools' allowlist). */
-    readonlyDirNamesUnderRoot(handle: MemorySessionHandle): Set<string>;
     /** Projection write: reads the target to skip a no-op, then writes — the same check-then-use shape
      *  as the containment restores, so it takes the same no-follow write. A link at a projection path
      *  is never a supported layout (the harvest scan refuses symlinked entry files outright), and this
@@ -1699,12 +1704,8 @@ export declare class MemoryEngine {
      * `getByIds` there would sync-adopt mid-harvest.
      */
     private debtCommittedProjection;
-    /** Sibling scope subdir names under `dir` (excluded from a scope-tree walk when `dir` is the root —
-     *  a root-owning layer's chmod/restore must never touch another scope's home). */
-    private siblingScopeDirNames;
-    /** chmod a scope's entry tree (best-effort; skipRoot leaves the top dir writable — used when a
-     *  read-only layer's dir IS the shared root / an ancestor of the writable root, which must stay
-     *  traversable+writable; excludeTopDirs skips sibling scope homes under a root-owning layer).
+    /** chmod a scope's entry tree (best-effort). The tree is the scope's own home and nothing else —
+     *  no other scope's directory can lie under it.
      *
      *  `opts.announced` is the CALLER's per-materialize ledger of paths already disclosed (#495 M-1).
      *  One materialize sweeps each inherited tree TWICE — restore write perms at the top, re-apply