@ouro.bot/cli 0.1.0-alpha.96 → 0.1.0-alpha.960

package/dist/mind/session-transaction.js

@@ -0,0 +1,622 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionTransactionError = exports.SessionTurnBusyError = void 0;
+exports.admitSessionActivity = admitSessionActivity;
+exports.acquireSessionTurnLease = acquireSessionTurnLease;
+exports.withSessionTurnLease = withSessionTurnLease;
+exports.withImmediateSessionTurnLease = withImmediateSessionTurnLease;
+exports.currentSessionTurnLease = currentSessionTurnLease;
+exports.assertSessionTurnLease = assertSessionTurnLease;
+exports.readSessionTransaction = readSessionTransaction;
+exports.writeSessionTransaction = writeSessionTransaction;
+exports.deleteSessionTransaction = deleteSessionTransaction;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const runtime_1 = require("../nerves/runtime");
+const habit_lifecycle_1 = require("../heart/habits/habit-lifecycle");
+class SessionTurnBusyError extends Error {
+    retryable = true;
+    constructor(message = "session turn is busy") {
+        super(message);
+        this.name = "SessionTurnBusyError";
+    }
+}
+exports.SessionTurnBusyError = SessionTurnBusyError;
+class SessionTransactionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SessionTransactionError";
+    }
+}
+exports.SessionTransactionError = SessionTransactionError;
+const heldLeases = new Map();
+const leaseContext = new node_async_hooks_1.AsyncLocalStorage();
+function canonicalSessionPath(sessionPath) {
+    return path.resolve(sessionPath);
+}
+function revision(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes, "utf8").digest("hex");
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isSqliteBusy(error) {
+    return error instanceof Error && "code" in error
+        && error.code === "SQLITE_BUSY";
+}
+function refuseConfinement() {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn", component: "mind", event: "mind.session_confinement_refused",
+        message: "session confinement is invalid or changed", meta: { action: "refused" },
+    });
+    throw new SessionTransactionError("session confinement is invalid or changed");
+}
+function confinedFile(filePath) {
+    let stat;
+    try {
+        stat = fs.lstatSync(filePath, { bigint: true });
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return null;
+        return refuseConfinement();
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        return refuseConfinement();
+    return stat;
+}
+function checkConfinement(pin) {
+    if (!pin)
+        return;
+    for (const directory of pin.directories) {
+        let stat;
+        try {
+            stat = fs.lstatSync(directory.path, { bigint: true });
+        }
+        catch {
+            return refuseConfinement();
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink() || stat.dev !== directory.dev || stat.ino !== directory.ino)
+            return refuseConfinement();
+    }
+    for (const suffix of ["", ".turn.lock", ".turn.lock-journal", ".turn.lock-wal", ".turn.lock-shm"]) {
+        confinedFile(`${pin.sessionPath}${suffix}`);
+    }
+}
+function pinConfinement(sessionPath, root) {
+    if (root === undefined)
+        return null;
+    if (typeof root !== "string" || !path.isAbsolute(root) || path.resolve(root) !== root)
+        return refuseConfinement();
+    const relative = path.relative(root, sessionPath);
+    if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+        return refuseConfinement();
+    const parent = path.dirname(sessionPath);
+    const volumeRoot = path.parse(parent).root;
+    let current = volumeRoot;
+    const paths = [current];
+    for (const segment of parent.slice(volumeRoot.length).split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        paths.push(current);
+    }
+    const directories = paths.map((directory) => {
+        let stat;
+        try {
+            stat = fs.lstatSync(directory, { bigint: true });
+        }
+        catch {
+            return refuseConfinement();
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return refuseConfinement();
+        return { path: directory, dev: stat.dev, ino: stat.ino };
+    });
+    const pin = { root, sessionPath, directories };
+    checkConfinement(pin);
+    return pin;
+}
+function retainConfinement(held, requestedRoot) {
+    if (requestedRoot !== undefined && requestedRoot !== held.confinement?.root)
+        return refuseConfinement();
+    checkConfinement(held.confinement);
+}
+function checkTemporary(pin, filePath, identity) {
+    checkConfinement(pin);
+    const current = confinedFile(filePath);
+    if (!current || !identity || current.dev !== identity.dev || current.ino !== identity.ino)
+        return refuseConfinement();
+}
+function openLeaseDatabase(lockPath, busyTimeoutMs = 0, confinement = null) {
+    checkConfinement(confinement);
+    const database = new better_sqlite3_1.default(lockPath);
+    try {
+        database.pragma(`busy_timeout = ${busyTimeoutMs}`);
+        database.transaction(() => {
+            database.exec(`
+        CREATE TABLE IF NOT EXISTS session_turn_lease (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          pid INTEGER NOT NULL,
+          owner_id TEXT NOT NULL,
+          owner_token TEXT NOT NULL
+        )
+      `);
+            const columns = new Set(database.prepare(`PRAGMA table_info(session_turn_lease)`).all().map((column) => column.name));
+            if (!columns.has("boot_identity"))
+                database.exec(`ALTER TABLE session_turn_lease ADD COLUMN boot_identity TEXT`);
+            if (!columns.has("process_started_at"))
+                database.exec(`ALTER TABLE session_turn_lease ADD COLUMN process_started_at TEXT`);
+        }).immediate();
+        return database;
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+}
+/** Immutable admission, not proof of execution or delivery. Unknown effects must never be replayed. */
+function admitSessionActivity(sessionPath, input) {
+    if (typeof input.namespace !== "string" || !input.namespace.trim() || Buffer.byteLength(input.namespace) > 4096
+        || typeof input.activityId !== "string" || !input.activityId.trim() || Buffer.byteLength(input.activityId) > 1024
+        || typeof input.payloadDigest !== "string" || !/^[a-f0-9]{64}$/.test(input.payloadDigest)) {
+        throw new SessionTransactionError("invalid session activity admission");
+    }
+    const canonical = canonicalSessionPath(sessionPath);
+    const lockPath = `${canonical}.turn.lock`;
+    fs.mkdirSync(path.dirname(canonical), { recursive: true, mode: 0o700 });
+    const receiptId = revision(JSON.stringify([input.namespace, input.activityId]));
+    const database = openLeaseDatabase(lockPath, 1000);
+    try {
+        database.pragma("synchronous = FULL");
+        const state = database.transaction(() => {
+            database.exec(`
+        CREATE TABLE IF NOT EXISTS session_activity_receipts (
+          receipt_id TEXT PRIMARY KEY,
+          payload_digest TEXT NOT NULL,
+          admitted_at TEXT NOT NULL
+        )
+      `);
+            const existing = database.prepare("SELECT payload_digest FROM session_activity_receipts WHERE receipt_id = ?")
+                .get(receiptId);
+            if (existing) {
+                if (typeof existing.payload_digest !== "string" || !/^[a-f0-9]{64}$/.test(existing.payload_digest)) {
+                    throw new SessionTransactionError("invalid session activity receipt");
+                }
+                if (existing.payload_digest !== input.payloadDigest)
+                    throw new SessionTransactionError("conflicting session activity payload");
+                return "duplicate";
+            }
+            // Never evict an admission: losing its identity would authorize uncertain work again.
+            if (fs.statSync(lockPath).size >= 64 * 1024 * 1024)
+                throw new SessionTransactionError("session activity receipt capacity exceeded");
+            database.prepare("INSERT INTO session_activity_receipts (receipt_id, payload_digest, admitted_at) VALUES (?, ?, ?)")
+                .run(receiptId, input.payloadDigest, new Date().toISOString());
+            return "admitted";
+        }).immediate();
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind", event: "mind.session_activity_admission", message: "recorded session activity admission decision",
+            meta: { receiptId, state },
+        });
+        return { state, receiptId };
+    }
+    finally {
+        database.close();
+    }
+}
+function acquisitionRecord(options) {
+    const pid = options.pid ?? process.pid;
+    const bootIdentity = (options.getBootIdentity ?? habit_lifecycle_1.probeHabitBootIdentity)();
+    const processStartedAt = (options.getProcessStartedAt ?? habit_lifecycle_1.probeHabitProcessStartedAt)(pid);
+    if (!bootIdentity || !processStartedAt)
+        throw new SessionTransactionError("current process identity is unavailable");
+    return {
+        pid,
+        ownerId: options.ownerId ?? (0, node_crypto_1.randomUUID)(),
+        ownerToken: options.ownerToken ?? (0, node_crypto_1.randomUUID)(),
+        bootIdentity,
+        processStartedAt,
+    };
+}
+function claimLeaseRecord(lockPath, record, isProcessAlive, getProcessStartedAt, confinement) {
+    const database = openLeaseDatabase(lockPath, 0, confinement);
+    try {
+        return database.transaction(() => {
+            const current = database.prepare(`
+        SELECT pid, owner_id, owner_token, boot_identity, process_started_at FROM session_turn_lease WHERE singleton = 1
+      `).get();
+            if (!current) {
+                checkConfinement(confinement);
+                database.prepare(`
+          INSERT INTO session_turn_lease (singleton, pid, owner_id, owner_token, boot_identity, process_started_at) VALUES (1, ?, ?, ?, ?, ?)
+        `).run(record.pid, record.ownerId, record.ownerToken, record.bootIdentity, record.processStartedAt);
+                return { acquired: true, stale: null };
+            }
+            if (!Number.isSafeInteger(current.pid) || current.pid <= 0
+                || typeof current.owner_id !== "string" || current.owner_id.length === 0
+                || typeof current.owner_token !== "string" || current.owner_token.length === 0
+                || !((current.boot_identity === null && current.process_started_at === null)
+                    || (typeof current.boot_identity === "string" && current.boot_identity.length > 0
+                        && typeof current.process_started_at === "string" && current.process_started_at.length > 0))) {
+                throw new SessionTransactionError("invalid session lease record");
+            }
+            const observed = {
+                pid: current.pid,
+                ownerId: current.owner_id,
+                ownerToken: current.owner_token,
+                bootIdentity: current.boot_identity,
+                processStartedAt: current.process_started_at,
+            };
+            const differentBoot = observed.bootIdentity !== null && observed.bootIdentity !== record.bootIdentity;
+            let differentProcess = false;
+            if (observed.bootIdentity !== null && !differentBoot) {
+                const liveStartedAt = getProcessStartedAt(observed.pid);
+                differentProcess = liveStartedAt !== null && liveStartedAt !== observed.processStartedAt;
+                if (liveStartedAt === observed.processStartedAt)
+                    return { acquired: false, stale: null };
+            }
+            if (!differentBoot && !differentProcess && isProcessAlive(observed.pid))
+                return { acquired: false, stale: null };
+            checkConfinement(confinement);
+            const changed = database.prepare(`
+        UPDATE session_turn_lease SET pid = ?, owner_id = ?, owner_token = ?, boot_identity = ?, process_started_at = ?
+        WHERE singleton = 1 AND pid = ? AND owner_id = ? AND owner_token = ?
+          AND boot_identity IS ? AND process_started_at IS ?
+      `).run(record.pid, record.ownerId, record.ownerToken, record.bootIdentity, record.processStartedAt, observed.pid, observed.ownerId, observed.ownerToken, observed.bootIdentity, observed.processStartedAt).changes;
+            return changed === 1 ? { acquired: true, stale: observed } : { acquired: false, stale: null };
+        })();
+    }
+    finally {
+        database.close();
+    }
+}
+function releaseLeaseRecord(lockPath, record) {
+    const database = openLeaseDatabase(lockPath, 5_000, record.confinement);
+    try {
+        return database.prepare(`
+      DELETE FROM session_turn_lease WHERE singleton = 1 AND pid = ? AND owner_id = ? AND owner_token = ?
+        AND boot_identity IS ? AND process_started_at IS ?
+    `).run(record.pid, record.ownerId, record.ownerToken, record.bootIdentity, record.processStartedAt).changes === 1;
+    }
+    finally {
+        database.close();
+    }
+}
+function makeLease(held) {
+    let localReleased = false;
+    const release = () => {
+        if (localReleased)
+            return;
+        localReleased = true;
+        held.depth -= 1;
+        if (held.depth > 0 || held.released)
+            return;
+        held.released = true;
+        try {
+            releaseLeaseRecord(held.lockPath, held);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn", component: "mind", event: "mind.session_turn_lease_release_failed",
+                message: "durable lease release failed; original recovery evidence retained",
+                meta: { sessionPath: held.sessionPath, ownerId: held.ownerId },
+            });
+            throw error;
+        }
+        finally {
+            if (heldLeases.get(held.sessionPath) === held)
+                heldLeases.delete(held.sessionPath);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.session_turn_lease_released",
+            message: "released session turn lease",
+            meta: { sessionPath: held.sessionPath, ownerId: held.ownerId },
+        });
+    };
+    return {
+        lease: {
+            sessionPath: held.sessionPath, ownerId: held.ownerId, ownerToken: held.ownerToken,
+            release: async () => release(),
+        },
+        release,
+    };
+}
+async function acquireSessionTurnLease(sessionPath, options = {}) {
+    const canonical = canonicalSessionPath(sessionPath);
+    const existing = heldLeases.get(canonical);
+    if (existing && !existing.released) {
+        if (options.ownerId === existing.ownerId && options.ownerToken === existing.ownerToken) {
+            retainConfinement(existing, options.confinementRoot);
+            existing.depth += 1;
+            return makeLease(existing).lease;
+        }
+    }
+    const confinement = pinConfinement(canonical, options.confinementRoot);
+    const record = acquisitionRecord(options);
+    const { ownerId } = record;
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 10;
+    const isProcessAlive = options.isProcessAlive ?? processAlive;
+    const lockPath = `${canonical}.turn.lock`;
+    const started = Date.now();
+    checkConfinement(confinement);
+    fs.mkdirSync(path.dirname(canonical), { recursive: true });
+    for (;;) {
+        let claim = null;
+        try {
+            claim = claimLeaseRecord(lockPath, record, isProcessAlive, options.getProcessStartedAt ?? habit_lifecycle_1.probeHabitProcessStartedAt, confinement);
+        }
+        catch (error) {
+            if (!isSqliteBusy(error))
+                throw error;
+        }
+        if (claim?.acquired) {
+            const held = { sessionPath: canonical, lockPath, ...record, depth: 1, released: false, confinement };
+            heldLeases.set(canonical, held);
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.session_turn_lease_acquired",
+                message: "acquired session turn lease",
+                meta: { sessionPath: canonical, ownerId },
+            });
+            if (claim.stale) {
+                options.onStaleLease?.(claim.stale);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.session_turn_lease_stolen",
+                    message: "stole stale session turn lease",
+                    meta: { sessionPath: canonical, stalePid: claim.stale.pid, staleOwnerId: claim.stale.ownerId },
+                });
+            }
+            return makeLease(held).lease;
+        }
+        if (Date.now() - started >= timeoutMs) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "mind",
+                event: "mind.session_turn_lease_busy",
+                message: "session turn lease acquisition timed out",
+                meta: { sessionPath: canonical, ownerId, timeoutMs },
+            });
+            throw new SessionTurnBusyError(`session turn busy: ${canonical}`);
+        }
+        await sleep(pollIntervalMs);
+    }
+}
+async function withSessionTurnLease(sessionPath, work, options = {}) {
+    const lease = await acquireSessionTurnLease(sessionPath, options);
+    let failed = false;
+    try {
+        return await leaseContext.run(lease, () => work(lease));
+    }
+    catch (error) {
+        failed = true;
+        throw error;
+    }
+    finally {
+        try {
+            await lease.release();
+        }
+        catch (error) {
+            if (!failed)
+                throw error;
+        }
+    }
+}
+function withImmediateSessionTurnLease(sessionPath, work, options = {}) {
+    const canonical = canonicalSessionPath(sessionPath);
+    const contextual = currentSessionTurnLease(canonical);
+    if (contextual) {
+        const held = heldLeases.get(canonical);
+        if (!held || held.released)
+            throw new SessionTransactionError("session lease owner token mismatch");
+        retainConfinement(held, options.confinementRoot);
+        return work(contextual);
+    }
+    const confinement = pinConfinement(canonical, options.confinementRoot);
+    const record = acquisitionRecord(options);
+    const lockPath = `${canonical}.turn.lock`;
+    checkConfinement(confinement);
+    fs.mkdirSync(path.dirname(canonical), { recursive: true });
+    const tryAcquire = () => {
+        let claim;
+        try {
+            claim = claimLeaseRecord(lockPath, record, options.isProcessAlive ?? processAlive, options.getProcessStartedAt ?? habit_lifecycle_1.probeHabitProcessStartedAt, confinement);
+        }
+        catch (error) {
+            if (isSqliteBusy(error))
+                return null;
+            throw error;
+        }
+        if (claim.acquired) {
+            const held = { sessionPath: canonical, lockPath, ...record, depth: 1, released: false, confinement };
+            heldLeases.set(canonical, held);
+            if (claim.stale) {
+                options.onStaleLease?.(claim.stale);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.session_turn_lease_stolen",
+                    message: "stole stale session turn lease",
+                    meta: { sessionPath: canonical, stalePid: claim.stale.pid, staleOwnerId: claim.stale.ownerId },
+                });
+            }
+            return held;
+        }
+        return null;
+    };
+    const held = tryAcquire();
+    if (!held)
+        throw new SessionTurnBusyError(`session turn busy: ${canonical}`);
+    const { lease, release } = makeLease(held);
+    let failed = false;
+    try {
+        return leaseContext.run(lease, () => work(lease));
+    }
+    catch (error) {
+        failed = true;
+        throw error;
+    }
+    finally {
+        try {
+            release();
+        }
+        catch (error) {
+            if (!failed)
+                throw error;
+        }
+    }
+}
+function currentSessionTurnLease(sessionPath) {
+    const lease = leaseContext.getStore();
+    return lease && lease.sessionPath === canonicalSessionPath(sessionPath) ? lease : null;
+}
+function assertSessionTurnLease(sessionPath, lease) {
+    const canonical = canonicalSessionPath(sessionPath);
+    if (lease.sessionPath !== canonical)
+        throw new SessionTransactionError("leased session path mismatch");
+    const held = heldLeases.get(canonical);
+    if (!held || held.released || held.ownerId !== lease.ownerId || held.ownerToken !== lease.ownerToken) {
+        throw new SessionTransactionError("session lease owner token mismatch");
+    }
+    checkConfinement(held.confinement);
+}
+function readSessionTransaction(sessionPath, lease) {
+    assertSessionTurnLease(sessionPath, lease);
+    let bytes = "";
+    try {
+        bytes = fs.readFileSync(canonicalSessionPath(sessionPath), "utf8");
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.code !== "ENOENT")
+            throw error;
+    }
+    return { bytes, value: bytes ? JSON.parse(bytes) : null, revision: revision(bytes) };
+}
+function writeSessionTransaction(sessionPath, value, options) {
+    assertSessionTurnLease(sessionPath, options.lease);
+    const canonical = canonicalSessionPath(sessionPath);
+    const confinement = heldLeases.get(canonical).confinement;
+    const current = readSessionTransaction(canonical, options.lease);
+    if (current.revision !== options.expectedRevision)
+        throw new SessionTransactionError("session revision changed");
+    fs.mkdirSync(path.dirname(canonical), { recursive: true });
+    const bytes = JSON.stringify(value, null, 2);
+    const tempPath = path.join(path.dirname(canonical), `.${path.basename(canonical)}.tmp-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    let fd = null;
+    let temporaryIdentity = null;
+    try {
+        fd = fs.openSync(tempPath, "wx", 0o600);
+        if (confinement)
+            temporaryIdentity = fs.fstatSync(fd, { bigint: true });
+        fs.writeFileSync(fd, bytes, "utf8");
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = null;
+        options.hooks?.beforeRename?.();
+        if (confinement)
+            checkTemporary(confinement, tempPath, temporaryIdentity);
+        fs.renameSync(tempPath, canonical);
+        checkConfinement(confinement);
+        const directoryFd = fs.openSync(path.dirname(canonical), "r");
+        try {
+            fs.fsyncSync(directoryFd);
+        }
+        finally {
+            fs.closeSync(directoryFd);
+        }
+    }
+    catch (error) {
+        /* v8 ignore next -- fd-close failure after a prior node:fs failure is best-effort cleanup @preserve */
+        if (fd !== null)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* best effort */ }
+        try {
+            if (confinement)
+                checkTemporary(confinement, tempPath, temporaryIdentity);
+            fs.unlinkSync(tempPath);
+        }
+        catch {
+            if (confinement)
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn", component: "mind", event: "mind.session_transaction_cleanup_refused",
+                    message: "temporary cleanup unavailable; original evidence retained",
+                    meta: { sessionPath: canonical },
+                });
+        }
+        throw error;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.session_transaction_written",
+        message: "durably replaced session envelope",
+        meta: { sessionPath: canonical, ownerId: options.lease.ownerId },
+    });
+    return revision(bytes);
+}
+function deleteSessionTransaction(sessionPath, lease) {
+    assertSessionTurnLease(sessionPath, lease);
+    try {
+        fs.unlinkSync(canonicalSessionPath(sessionPath));
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.code !== "ENOENT")
+            throw error;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.session_transaction_deleted",
+        message: "deleted session under turn lease",
+        meta: { sessionPath: canonicalSessionPath(sessionPath), ownerId: lease.ownerId },
+    });
+}

package/dist/nerves/cli-logging.js

@@ -28,7 +28,13 @@ function configureCliRuntimeLogger(_friendId, options = {}) {
             // for an interactive session. Full detail goes to the ndjson file.
             return filterSink((0, nerves_1.createTerminalSink)(), "warn");
         }
-        return (0, nerves_1.createNdjsonFileSink)((0, config_1.logPath)("cli", "runtime"));
+        // Rotation policy for the CLI runtime sink (Unit 1c):
+        // 25 MB x 5 gzipped generations, matching the daemon stream policy.
+        return (0, nerves_1.createNdjsonFileSink)((0, config_1.logPath)("cli", "runtime"), {
+            maxSizeBytes: 25 * 1024 * 1024,
+            maxGenerations: 5,
+            compress: true,
+        });
     });
     const logger = (0, nerves_1.createLogger)({
         level,

package/dist/nerves/coverage/audit-rules.js

@@ -2,16 +2,25 @@
 /**
  * Per-test audit rules for nerves event coverage.
  *
- * Rule 1: every-test-emits -- every test must emit at least one event
- * Rule 2: start/end pairing -- _start events must have matching _end or _error
+ * Rule 1: every-test-emits -- every captured test must emit at least one event
+ * Rule 2: lifecycle start/end pairing -- process-scoped _start events must have matching _end or _error
  * Rule 3: error context -- error-level events must have non-empty meta
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIFECYCLE_PAIRED_STARTS = void 0;
 exports.checkEveryTestEmits = checkEveryTestEmits;
 exports.checkStartEndPairing = checkStartEndPairing;
 exports.checkErrorContext = checkErrorContext;
+// Only these starts represent process-scoped lifecycle contracts. Most nerves
+// `_start` events are local operation markers that can be legitimately observed
+// by a narrow unit test without driving the whole operation to completion.
+exports.LIFECYCLE_PAIRED_STARTS = new Set([
+    "daemon.server_start",
+    "daemon.update_checker_start",
+    "daemon.apply_pending_updates_start",
+]);
 /**
- * Rule 1: Every test must emit at least one nerves event.
+ * Rule 1: Every captured test must emit at least one nerves event.
  */
 function checkEveryTestEmits(data) {
     if (!data || typeof data !== "object") {
@@ -22,13 +31,13 @@ function checkEveryTestEmits(data) {
         .filter(([, events]) => !Array.isArray(events) || events.length === 0)
         .map(([name]) => name);
     return {
-        status: silent.length === 0 ? "pass" : "fail",
+        status: entries.length > 0 && silent.length === 0 ? "pass" : "fail",
         total_tests: entries.length,
         silent_tests: silent,
     };
 }
 /**
- * Rule 2: _start events must have matching _end or _error within the same test.
+ * Rule 2: Process-scoped lifecycle _start events must have matching _end or _error within the same test.
  */
 function checkStartEndPairing(data) {
     if (!data || typeof data !== "object") {
@@ -39,7 +48,7 @@ function checkStartEndPairing(data) {
         if (!Array.isArray(events))
             continue;
         const eventNames = events.map((e) => e.event);
-        const startEvents = eventNames.filter((name) => name.endsWith("_start"));
+        const startEvents = eventNames.filter((name) => exports.LIFECYCLE_PAIRED_STARTS.has(name));
         for (const startEvent of startEvents) {
             const prefix = startEvent.slice(0, -"_start".length);
             const hasEnd = eventNames.some((name) => name === `${prefix}_end`);