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

package/dist/heart/session-redaction-repair.js

@@ -0,0 +1,552 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectA003LegacyRequiredCorrections = selectA003LegacyRequiredCorrections;
+exports.inspectA003SessionRepair = inspectA003SessionRepair;
+exports.applyA003SessionRepair = applyA003SessionRepair;
+exports.rollbackA003SessionRepair = rollbackA003SessionRepair;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const identity_1 = require("./identity");
+const runtime_1 = require("../nerves/runtime");
+const tool_arguments_1 = require("../repertoire/tool-arguments");
+const session_events_1 = require("./session-events");
+const structured_output_1 = require("./structured-output");
+const session_transaction_1 = require("../mind/session-transaction");
+const SCHEMA = "a003-sanctuary-session-repair-v1";
+const SELECTOR = "a003-legacy-required-corrections-v1";
+const TARGET_BINDINGS = [
+    { id: "evt-000347", sequence: 347 },
+    { id: "evt-000355", sequence: 355 },
+    { id: "evt-000363", sequence: 363 },
+    { id: "evt-000366", sequence: 366 },
+    { id: "evt-000369", sequence: 369 },
+    { id: "evt-000400", sequence: 400 },
+    { id: "evt-000447", sequence: 447 },
+    { id: "evt-000448", sequence: 448 },
+];
+const SESSION_LIMIT = 32 * 1024 * 1024;
+const MANIFEST_LIMIT = 1024 * 1024;
+const HASH = /^[a-f0-9]{64}$/u;
+function sha(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+}
+function refuse(reason) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn", component: "heart", event: "heart.session_redaction_repair_refused",
+        message: "fixed session repair refused", meta: { reason },
+    });
+    throw new Error(reason);
+}
+function exactKeys(value, keys) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        && Object.keys(value).length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function iso(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function sameInode(a, b) {
+    return a.dev === b.dev && a.ino === b.ino;
+}
+function directoryChain(directory) {
+    if (!path.isAbsolute(directory) || path.resolve(directory) !== directory)
+        refuse("noncanonical directory path");
+    let current = path.parse(directory).root;
+    const parts = [current];
+    for (const part of directory.slice(current.length).split(path.sep).filter(Boolean)) {
+        current = path.join(current, part);
+        parts.push(current);
+    }
+    return parts.map((file) => {
+        const stat = fs.lstatSync(file, { bigint: true });
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            refuse("directory symlink or type mismatch");
+        return { path: file, dev: stat.dev, ino: stat.ino };
+    });
+}
+function checkDirectories(pin) {
+    for (const entry of pin) {
+        const stat = fs.lstatSync(entry.path, { bigint: true });
+        if (!stat.isDirectory() || stat.isSymbolicLink() || !sameInode(entry, stat))
+            refuse("directory identity changed");
+    }
+}
+function privateDirectory(directory) {
+    const pin = directoryChain(directory);
+    if ((fs.lstatSync(directory, { bigint: true }).mode & 511n) !== 448n)
+        refuse("artifact directory must have mode 0700");
+    return pin;
+}
+function privateFile(file, label, limit) {
+    if (!path.isAbsolute(file) || path.resolve(file) !== file)
+        refuse("noncanonical file path");
+    directoryChain(path.dirname(file));
+    const stat = fs.lstatSync(file, { bigint: true });
+    if (!stat.isFile() || stat.isSymbolicLink())
+        refuse(`${label} must be a regular file`);
+    if ((stat.mode & 511n) !== 384n)
+        refuse(`${label} must have mode 0600`);
+    if (stat.size > BigInt(limit))
+        refuse(`${label} exceeds ${limit / (1024 * 1024)} MiB`);
+    return stat;
+}
+function readArtifact(file, label, limit) {
+    const pin = privateDirectory(path.dirname(file));
+    const original = privateFile(file, label, limit);
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    try {
+        const opened = fs.fstatSync(fd, { bigint: true });
+        if (!opened.isFile() || !sameInode(original, opened) || (opened.mode & 511n) !== 384n || opened.size > BigInt(limit))
+            refuse("artifact identity changed");
+        const bytes = fs.readFileSync(fd);
+        checkDirectories(pin);
+        if (bytes.length > limit || !sameInode(opened, fs.lstatSync(file, { bigint: true })))
+            refuse("artifact changed during read");
+        return bytes;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function sessionLocation(agent, sessionPath) {
+    if (agent !== "sanctuary")
+        refuse("repair agent must be sanctuary");
+    const root = path.join((0, identity_1.getAgentRoot)("sanctuary"), "state", "sessions");
+    directoryChain(root);
+    const relative = path.relative(root, sessionPath);
+    if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+        refuse("session path escapes sanctuary");
+    privateFile(sessionPath, "session", SESSION_LIMIT);
+    return { root, relative: relative.split(path.sep).join("/") };
+}
+function manifestSessionPath(relative) {
+    if (!relative || relative.includes("\\") || relative.split("/").some((part) => !part || part === "." || part === ".."))
+        refuse("invalid session relative path");
+    const file = path.join((0, identity_1.getAgentRoot)("sanctuary"), "state", "sessions", relative);
+    sessionLocation("sanctuary", file);
+    return file;
+}
+function marker(target, sequence, capturedAt) {
+    return {
+        id: `evt-${String(sequence).padStart(6, "0")}`, sequence, role: "system", content: null,
+        name: null, toolCallId: null, toolCalls: [], attachments: [],
+        time: {
+            authoredAt: null, authoredAtSource: "migration", observedAt: null, observedAtSource: "migration",
+            recordedAt: capturedAt, recordedAtSource: "migration",
+        },
+        relations: {
+            replyToEventId: null, threadRootEventId: null, references: [], toolCallId: null,
+            supersedesEventId: null, redactsEventId: target.id,
+        },
+        provenance: { captureKind: "migration", legacyVersion: 2, sourceMessageIndex: null },
+    };
+}
+// Frozen constructor inputs, not a text/regex classifier and not live policy.
+// The first media wording is the constructor shipped at 2efc01e5; the other
+// finite variants are present in the P0 Sanctuary required-read contracts.
+const LEGACY_CORRECTIONS = new Set();
+for (const [text, names] of [
+    ["Before answering, read current active work, cares, system health, and service state. Then give Ari one compact household summary; do not ask him to choose a status slice.", ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers"]],
+    ["Before answering, read current active work, cares, system health, service state, storage, and the download queue. Current tool facts outrank care history; a stale care is a recheck item, not a present-tense fact. Then give Ari one compact household summary; do not ask him to choose a status slice.", ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers", "unraid_get_storage", "sanctuary_get_download_queue"]],
+    ["Run both safe reads now, identify the largest measured evidence, report Unmanic and Jellyfin findings, and propose a sample encode without inventing future savings. Do not ask permission or send Ari to a shell or QDirStat while these typed reads are available.", ["unraid_get_storage", "sanctuary_get_media_optimization"]],
+    ["Run both safe reads now, identify the largest measured evidence, report Unmanic and Jellyfin findings, and propose a sample encode without inventing future savings. If one read returns a degraded or partial result, continue with the other safe reads and bounded container/log tools before answering. Do not ask permission or send Ari to a shell, dashboard, logs, or QDirStat while these typed reads are available.", ["unraid_get_storage", "sanctuary_get_media_optimization"]],
+    ["Before answering, read current active work, cares, system health, service state, storage, notifications, and the download queue. Current tool facts outrank care history; a stale care is a recheck item, not a present-tense fact. Then give Ari one compact household summary; do not ask him to choose a status slice.", ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers", "unraid_get_storage", "unraid_get_notifications", "sanctuary_get_download_queue"]],
+]) {
+    for (let bits = 1; bits < 2 ** names.length; bits++) {
+        LEGACY_CORRECTIONS.add(`${text} Missing required tool calls: ${names.filter((_name, index) => (bits & (1 << index)) !== 0).join(", ")}.`);
+    }
+}
+for (const text of [
+    "Use sanctuary_search_media_catalog before answering. If asked for taste or a favorite, form a light recommendation from returned catalog evidence instead of claiming you cannot have preferences. Keep it honest: say you cannot watch, but you can pick from the household shelf.",
+    "Use sanctuary_search_media_catalog before answering. If a broader media-optimization read fails or degrades, treat that as a diagnostic note and still use the catalog tool for ordinary library visibility questions. If asked for taste or a favorite, form a light recommendation from returned catalog evidence instead of claiming you cannot have preferences. Keep it honest: say you cannot watch, but you can pick from the household shelf.",
+    "Use sanctuary_search_media_catalog before answering, then report only the current shelf count in ordinary household language.",
+    "Use sanctuary_search_media_catalog before answering. Lead with the direct answer from current catalog evidence, report the shelf count in ordinary household language, and stop without sampled titles or a follow-up question.",
+    "Use sanctuary_search_media_catalog with the requested title before answering. Confirm its presence or absence directly from current catalog evidence.",
+    "Use sanctuary_search_media_catalog before answering. Make one concise, decisive choice grounded in returned catalog evidence; do not volunteer an AI or 'I cannot watch' disclaimer.",
+    "Use sanctuary_search_media_catalog before answering and base any named titles on the returned catalog evidence.",
+    ...Array.from({ length: 20 }, (_, index) => `Use sanctuary_search_media_catalog with limit ${index + 1} before answering, then name exactly the returned catalog titles.`),
+])
+    LEGACY_CORRECTIONS.add(`${text} Missing required tool calls: sanctuary_search_media_catalog.`);
+function selectA003LegacyRequiredCorrections(rawEvents) {
+    if (!Array.isArray(rawEvents) || rawEvents.length === 0)
+        refuse("legacy event set is missing");
+    const events = rawEvents;
+    if (events.some((event) => !event || typeof event !== "object" || event.relations?.redactsEventId != null))
+        refuse("legacy event set has a redaction conflict");
+    const max = events.reduce((value, event) => Math.max(value, event.sequence), 0);
+    const targets = TARGET_BINDINGS.map(({ id, sequence }) => events.find((event) => event.id === id && event.sequence === sequence));
+    for (const target of targets) {
+        if (!target || typeof target.content !== "string" || !LEGACY_CORRECTIONS.has(target.content)
+            || !(0, session_events_1.isExactRawSessionRedactionMarker)(marker(target, max + 1, "1970-01-01T00:00:00.000Z"), [...events, marker(target, max + 1, "1970-01-01T00:00:00.000Z")])
+            || target.name !== null || target.toolCallId !== null || target.toolCalls.length !== 0 || target.attachments.length !== 0
+            || target.provenance.captureKind !== "live" || target.provenance.legacyVersion !== null || target.provenance.sourceMessageIndex !== null
+            || target.time.authoredAt !== null || target.time.authoredAtSource !== "unknown" || target.time.observedAtSource !== "ingest"
+            || target.time.recordedAtSource !== "save" || target.time.observedAt !== target.time.recordedAt
+            || !(0, node_util_1.isDeepStrictEqual)(target.relations, { replyToEventId: null, threadRootEventId: null, references: [], toolCallId: null, supersedesEventId: null, redactsEventId: null }))
+            refuse("legacy correction constructor mismatch");
+    }
+    if (events.filter((event) => typeof event.content === "string" && LEGACY_CORRECTIONS.has(event.content)).length !== TARGET_BINDINGS.length)
+        refuse("extra or ambiguous legacy corrections");
+    return targets;
+}
+function rawEnvelope(bytes) {
+    if (Buffer.byteLength(bytes) > SESSION_LIMIT)
+        refuse("session exceeds 32 MiB");
+    const value = JSON.parse(bytes);
+    const parsed = (0, session_events_1.parseSessionEnvelope)(value);
+    if (!parsed || !value || typeof value !== "object" || value.version !== 2)
+        refuse("session must be a v2 envelope");
+    const envelope = value;
+    if (JSON.stringify(value, null, 2) !== bytes)
+        refuse("session bytes are not canonical transaction serialization");
+    if (!(0, node_util_1.isDeepStrictEqual)(envelope.events, parsed.events))
+        refuse("session requires normalization");
+    const projection = envelope.projection;
+    if (!exactKeys(projection, ["eventIds", "trimmed", "maxTokens", "contextMargin", "inputTokens", "projectedAt"])
+        || !Array.isArray(projection.eventIds) || projection.eventIds.some((id) => typeof id !== "string")
+        || typeof projection.trimmed !== "boolean"
+        || ![projection.maxTokens, projection.contextMargin, projection.inputTokens].every((value) => value === null || typeof value === "number")
+        || !(projection.projectedAt === null || iso(projection.projectedAt)))
+        refuse("invalid session projection");
+    const byId = new Map(envelope.events.map((event) => [event.id, event]));
+    const seenIds = new Set();
+    let sequence = 0;
+    for (const [index, id] of projection.eventIds.entries()) {
+        const event = byId.get(id);
+        if (!event || seenIds.has(id))
+            refuse("invalid projection order or identity");
+        seenIds.add(id);
+        if (index === 0 && event.role === "system")
+            continue;
+        if (event.sequence <= sequence)
+            refuse("invalid projection order or identity");
+        sequence = event.sequence;
+    }
+    return envelope;
+}
+function projectedStructuredOutputs(envelope) {
+    const byId = new Map(envelope.events.map((event) => [event.id, event]));
+    const events = (0, session_events_1.projectedSessionEventIds)(envelope).map((id) => byId.get(id));
+    return (0, structured_output_1.extractStructuredOutputsFromEvents)(events, { emitTelemetry: false });
+}
+function compute(bytes, relative, capturedAt) {
+    const envelope = rawEnvelope(bytes);
+    const targets = selectA003LegacyRequiredCorrections(envelope.events);
+    const max = envelope.events.reduce((value, event) => Math.max(value, event.sequence), 0);
+    const entries = targets.map((target, index) => {
+        const position = envelope.events.indexOf(target);
+        return {
+            target, targetSha256: (0, tool_arguments_1.digestJson)(target),
+            previousEventId: envelope.events[position - 1]?.id ?? null,
+            nextEventId: envelope.events[position + 1]?.id ?? null,
+            marker: marker(target, max + index + 1, capturedAt),
+        };
+    });
+    const events = [...envelope.events, ...entries.map((entry) => entry.marker)];
+    if (!entries.every((entry) => (0, session_events_1.isExactRawSessionRedactionMarker)(entry.marker, events)))
+        refuse("invalid computed marker block");
+    const removed = new Set(entries.flatMap((entry) => [entry.target.id, entry.marker.id]));
+    const selected = new Set((0, session_events_1.projectedSessionEventIds)(envelope).filter((id) => !removed.has(id)));
+    const postimage = {
+        ...envelope, events,
+        projection: {
+            ...envelope.projection, eventIds: envelope.projection.eventIds.filter((id) => !removed.has(id)),
+            trimmed: envelope.projection.trimmed || (0, session_events_1.selectEffectiveSessionEvents)(events).some((event) => !selected.has(event.id)),
+        },
+    };
+    postimage.structuredOutputs = projectedStructuredOutputs(postimage);
+    const postBytes = JSON.stringify(postimage, null, 2);
+    if (Buffer.byteLength(postBytes) > SESSION_LIMIT)
+        refuse("postimage exceeds 32 MiB");
+    return {
+        manifest: { schemaVersion: SCHEMA, selectorVersion: SELECTOR, agent: "sanctuary", sessionRelativePath: relative, capturedAt, preimageRevision: sha(bytes), postimageRevision: sha(postBytes), entries },
+        postimage,
+    };
+}
+function readManifest(authority) {
+    if (typeof authority.manifestSha256 !== "string" || !HASH.test(authority.manifestSha256))
+        refuse("invalid manifest hash");
+    const bytes = readArtifact(authority.manifestPath, "manifest", MANIFEST_LIMIT);
+    if (sha(bytes) !== authority.manifestSha256)
+        refuse("manifest hash changed");
+    const value = JSON.parse(bytes.toString("utf8"));
+    if (!exactKeys(value, ["schemaVersion", "selectorVersion", "agent", "sessionRelativePath", "capturedAt", "preimageRevision", "postimageRevision", "entries"])
+        || value.schemaVersion !== SCHEMA || value.selectorVersion !== SELECTOR || value.agent !== "sanctuary"
+        || typeof value.sessionRelativePath !== "string" || !iso(value.capturedAt)
+        || typeof value.preimageRevision !== "string" || !HASH.test(value.preimageRevision)
+        || typeof value.postimageRevision !== "string" || !HASH.test(value.postimageRevision)
+        || !Array.isArray(value.entries) || value.entries.length !== TARGET_BINDINGS.length
+        || JSON.stringify(value, null, 2) !== bytes.toString("utf8"))
+        refuse("invalid closed repair manifest");
+    for (const entry of value.entries) {
+        if (!exactKeys(entry, ["target", "targetSha256", "previousEventId", "nextEventId", "marker"])
+            || typeof entry.targetSha256 !== "string" || !HASH.test(entry.targetSha256)
+            || ![entry.previousEventId, entry.nextEventId].every((id) => id === null || typeof id === "string" && id.trim().length > 0))
+            refuse("invalid manifest entry");
+    }
+    const manifest = value;
+    const targets = selectA003LegacyRequiredCorrections(manifest.entries.map((entry) => entry.target));
+    const block = manifest.entries.map((entry) => entry.marker);
+    for (let index = 0; index < manifest.entries.length; index++) {
+        const entry = manifest.entries[index];
+        if (!(0, node_util_1.isDeepStrictEqual)(entry.target, targets[index])
+            || entry.targetSha256 !== (0, tool_arguments_1.digestJson)(entry.target)
+            || !(0, session_events_1.isExactRawSessionRedactionMarker)(entry.marker, [...targets, ...block])
+            || !(0, node_util_1.isDeepStrictEqual)(entry.marker, marker(entry.target, block[0].sequence + index, manifest.capturedAt)))
+            refuse("manifest target or marker mismatch");
+    }
+    return manifest;
+}
+function publishArtifacts(directory, artifacts) {
+    const pin = privateDirectory(directory);
+    for (const artifact of artifacts) {
+        try {
+            fs.lstatSync(artifact.path, { bigint: true });
+            refuse("final artifact already exists");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    const created = [];
+    try {
+        for (const artifact of artifacts) {
+            checkDirectories(pin);
+            const record = { temporary: path.join(directory, `.${path.basename(artifact.path)}.${(0, node_crypto_1.randomUUID)()}`), final: artifact.path, identity: null, published: false };
+            created.push(record);
+            const fd = fs.openSync(record.temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
+            try {
+                record.identity = fs.fstatSync(fd, { bigint: true });
+                fs.writeFileSync(fd, artifact.bytes);
+                fs.fsyncSync(fd);
+            }
+            catch (error) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch {
+                    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "heart", event: "heart.session_repair_artifact_cleanup_refused", message: "artifact descriptor cleanup failed; primary error retained", meta: { stage: "descriptor" } });
+                }
+                throw error;
+            }
+            fs.closeSync(fd);
+            checkDirectories(pin);
+            fs.linkSync(record.temporary, record.final);
+            record.published = true;
+            const directoryFd = fs.openSync(directory, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            try {
+                fs.fsyncSync(directoryFd);
+            }
+            finally {
+                fs.closeSync(directoryFd);
+            }
+            checkDirectories(pin);
+            const readFd = fs.openSync(record.final, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            try {
+                const stat = fs.fstatSync(readFd, { bigint: true });
+                if (!stat.isFile() || !sameInode(record.identity, stat) || (stat.mode & 511n) !== 384n || stat.size !== BigInt(artifact.bytes.length)
+                    || sha(fs.readFileSync(readFd)) !== sha(artifact.bytes))
+                    refuse("published artifact identity or hash mismatch");
+            }
+            finally {
+                fs.closeSync(readFd);
+            }
+        }
+    }
+    catch (error) {
+        for (const record of created) {
+            if (!record.published || !record.identity)
+                continue;
+            try {
+                checkDirectories(pin);
+                const current = fs.lstatSync(record.final, { bigint: true });
+                if (current.isFile() && !current.isSymbolicLink() && sameInode(current, record.identity))
+                    fs.unlinkSync(record.final);
+            }
+            catch {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "heart", event: "heart.session_repair_artifact_cleanup_refused", message: "artifact cleanup could not safely address its original file", meta: { stage: "final" } });
+            }
+        }
+        throw error;
+    }
+    finally {
+        for (const record of created) {
+            if (!record.identity)
+                continue;
+            try {
+                checkDirectories(pin);
+                const current = fs.lstatSync(record.temporary, { bigint: true });
+                if (current.isFile() && !current.isSymbolicLink() && sameInode(current, record.identity))
+                    fs.unlinkSync(record.temporary);
+            }
+            catch {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "heart", event: "heart.session_repair_artifact_cleanup_refused", message: "artifact cleanup could not safely address its original file", meta: { stage: "sibling" } });
+            }
+        }
+    }
+}
+async function inspectA003SessionRepair(input) {
+    const location = sessionLocation(input.agent, input.sessionPath);
+    privateDirectory(input.artifactsDir);
+    return (0, session_transaction_1.withSessionTurnLease)(input.sessionPath, async (lease) => {
+        privateFile(input.sessionPath, "session", SESSION_LIMIT);
+        const current = (0, session_transaction_1.readSessionTransaction)(input.sessionPath, lease);
+        const { manifest } = compute(current.bytes, location.relative, new Date().toISOString());
+        const manifestBytes = Buffer.from(JSON.stringify(manifest, null, 2));
+        if (manifestBytes.length > MANIFEST_LIMIT)
+            refuse("manifest exceeds 1 MiB");
+        const manifestPath = path.join(input.artifactsDir, "a003-session-manifest.json");
+        const preimagePath = path.join(input.artifactsDir, "a003-session-preimage.json");
+        publishArtifacts(input.artifactsDir, [{ path: preimagePath, bytes: Buffer.from(current.bytes) }, { path: manifestPath, bytes: manifestBytes }]);
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.session_redaction_repair_inspected", message: "fixed repair inspected without session mutation", meta: { targetCount: manifest.entries.length } });
+        return { status: "inspected", manifestPath, preimagePath, manifestSha256: sha(manifestBytes), preimageRevision: manifest.preimageRevision, postimageRevision: manifest.postimageRevision };
+    }, { confinementRoot: location.root });
+}
+function alreadyApplied(envelope, manifest, currentRevision) {
+    const blockIndex = envelope.events.findIndex((event) => event.id === manifest.entries[0].marker.id);
+    if (blockIndex < 0 || !(0, node_util_1.isDeepStrictEqual)(envelope.events.slice(blockIndex, blockIndex + TARGET_BINDINGS.length), manifest.entries.map((entry) => entry.marker)))
+        return false;
+    if (currentRevision !== manifest.postimageRevision && envelope.events.at(-1).sequence <= manifest.entries.at(-1).marker.sequence)
+        return false;
+    try {
+        const targets = selectA003LegacyRequiredCorrections(envelope.events.slice(0, blockIndex));
+        if (!(0, node_util_1.isDeepStrictEqual)(targets, manifest.entries.map((entry) => entry.target)))
+            return false;
+    }
+    catch {
+        return false;
+    }
+    const marked = envelope.events.filter((event) => event.relations.redactsEventId !== null);
+    if (!(0, node_util_1.isDeepStrictEqual)(marked, manifest.entries.map((entry) => entry.marker))
+        || !marked.every((event) => (0, session_events_1.isExactRawSessionRedactionMarker)(event, envelope.events)))
+        return false;
+    const effective = (0, session_events_1.selectEffectiveSessionEvents)(envelope.events);
+    const visible = new Set(effective.map((event) => event.id));
+    return envelope.projection.eventIds.every((id) => visible.has(id))
+        && (0, node_util_1.isDeepStrictEqual)(envelope.structuredOutputs, projectedStructuredOutputs(envelope));
+}
+async function reconcileWrite(sessionPath, lease, value, before, after, success) {
+    try {
+        (0, session_transaction_1.writeSessionTransaction)(sessionPath, value, { lease, expectedRevision: before });
+    }
+    catch {
+        // A throw may occur after rename; only exact, still-confined readback decides.
+    }
+    try {
+        privateFile(sessionPath, "session", SESSION_LIMIT);
+        const current = (0, session_transaction_1.readSessionTransaction)(sessionPath, lease);
+        if (current.revision === after)
+            return { status: success, revision: after };
+        if (current.revision === before)
+            return { status: "not_applied", revision: before };
+    }
+    catch {
+        return { status: "indeterminate" };
+    }
+    return { status: "indeterminate" };
+}
+async function applyA003SessionRepair(authority) {
+    const manifest = readManifest(authority);
+    const sessionPath = manifestSessionPath(manifest.sessionRelativePath);
+    const { root } = sessionLocation("sanctuary", sessionPath);
+    let attemptedWrite = false;
+    try {
+        const result = await (0, session_transaction_1.withSessionTurnLease)(sessionPath, async (lease) => {
+            privateFile(sessionPath, "session", SESSION_LIMIT);
+            const current = (0, session_transaction_1.readSessionTransaction)(sessionPath, lease);
+            if (current.revision !== manifest.preimageRevision) {
+                let envelope;
+                try {
+                    envelope = rawEnvelope(current.bytes);
+                }
+                catch {
+                    return { status: "indeterminate" };
+                }
+                if (alreadyApplied(envelope, manifest, current.revision))
+                    return { status: "already_applied", revision: current.revision };
+                if (!envelope.events.some((event) => event.relations.redactsEventId !== null))
+                    refuse("session preimage revision changed");
+                return { status: "indeterminate" };
+            }
+            const computed = compute(current.bytes, manifest.sessionRelativePath, manifest.capturedAt);
+            if (!(0, node_util_1.isDeepStrictEqual)(computed.manifest, manifest))
+                refuse("manifest differs from independently computed repair");
+            attemptedWrite = true;
+            return reconcileWrite(sessionPath, lease, computed.postimage, manifest.preimageRevision, manifest.postimageRevision, "applied");
+        }, { confinementRoot: root });
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.session_redaction_repair_applied", message: "fixed repair apply readback classified", meta: { status: result.status } });
+        return result;
+    }
+    catch (error) {
+        if (attemptedWrite)
+            return { status: "indeterminate" };
+        throw error;
+    }
+}
+async function rollbackA003SessionRepair(authority) {
+    const manifest = readManifest(authority);
+    const preimage = readArtifact(authority.preimagePath, "preimage", SESSION_LIMIT);
+    if (sha(preimage) !== manifest.preimageRevision)
+        refuse("preimage digest mismatch");
+    const computed = compute(preimage.toString("utf8"), manifest.sessionRelativePath, manifest.capturedAt);
+    if (!(0, node_util_1.isDeepStrictEqual)(computed.manifest, manifest))
+        refuse("rollback manifest differs from preimage");
+    const value = JSON.parse(preimage.toString("utf8"));
+    const sessionPath = manifestSessionPath(manifest.sessionRelativePath);
+    const { root } = sessionLocation("sanctuary", sessionPath);
+    let attemptedWrite = false;
+    try {
+        const result = await (0, session_transaction_1.withSessionTurnLease)(sessionPath, async (lease) => {
+            privateFile(sessionPath, "session", SESSION_LIMIT);
+            const current = (0, session_transaction_1.readSessionTransaction)(sessionPath, lease);
+            if (current.revision === manifest.preimageRevision)
+                return { status: "already_rolled_back", revision: current.revision };
+            if (current.revision !== manifest.postimageRevision)
+                refuse("rollback requires the exact untouched postimage");
+            attemptedWrite = true;
+            return reconcileWrite(sessionPath, lease, value, manifest.postimageRevision, manifest.preimageRevision, "rolled_back");
+        }, { confinementRoot: root });
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.session_redaction_repair_rolled_back", message: "fixed repair rollback readback classified", meta: { status: result.status } });
+        return result;
+    }
+    catch (error) {
+        if (attemptedWrite)
+            return { status: "indeterminate" };
+        throw error;
+    }
+}

package/dist/heart/session-stats-cli-main.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const session_stats_1 = require("./session-stats");
+const code = (0, session_stats_1.runSessionStatsCli)(process.argv.slice(2));
+process.exit(code);