@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/mind/session-transaction.js

@@ -0,0 +1,564 @@
+"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.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);
+    database.pragma(`busy_timeout = ${busyTimeoutMs}`);
+    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`);
+    return database;
+}
+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`);

package/dist/nerves/coverage/audit.js

@@ -69,12 +69,38 @@ function readPerTestData(perTestPath) {
     if (!perTestPath || !(0, fs_1.existsSync)(perTestPath))
         return null;
     try {
-        return JSON.parse((0, fs_1.readFileSync)(perTestPath, "utf8"));
+        const raw = (0, fs_1.readFileSync)(perTestPath, "utf8").trim();
+        if (!raw)
+            return null;
+        try {
+            const parsed = JSON.parse(raw);
+            if (isPerTestRecord(parsed)) {
+                return { [parsed.testName]: parsed.events };
+            }
+            return parsed;
+        }
+        catch {
+            const perTestData = {};
+            for (const line of raw.split("\n").map((entry) => entry.trim()).filter(Boolean)) {
+                const parsed = JSON.parse(line);
+                if (!isPerTestRecord(parsed))
+                    return null;
+                const existing = perTestData[parsed.testName] ?? [];
+                perTestData[parsed.testName] = existing.concat(parsed.events);
+            }
+            return perTestData;
+        }
     }
     catch {
         return null;
     }
 }
+function isPerTestRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.testName === "string" && Array.isArray(record.events);
+}
 function scanSourceFiles(sourceRoot) {
     const filesWithKeys = new Map();
     const fileContents = new Map();
@@ -92,7 +118,7 @@ function scanSourceFiles(sourceRoot) {
                     continue;
                 walkDir(full);
             }
-            else if (entry.name.endsWith(".ts")) {
+            else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
                 const content = (0, fs_1.readFileSync)(full, "utf8");
                 const relPath = full.slice(root.length - "src".length);
                 fileContents.set(relPath, content);

package/dist/nerves/coverage/cli.js

@@ -35,7 +35,7 @@ function runAuditCli(argv) {
         return 2;
     }
     const eventsPath = args.eventsPath ?? (0, path_1.join)(runDir, "vitest-events.ndjson");
-    const perTestPath = args.perTestPath ?? (0, path_1.join)(runDir, "vitest-events-per-test.json");
+    const perTestPath = args.perTestPath ?? (0, path_1.join)(runDir, "vitest-events-per-test.ndjson");
     const sourceRoot = args.sourceRoot ?? (0, path_1.resolve)("src");
     const outputPath = args.output ?? (0, path_1.join)(runDir, "nerves-coverage.json");
     const report = (0, audit_1.auditNervesCoverage)({