pi-mega-compact 0.16.3 → 0.17.1

package/dist/src/vector-cortex/ledger/emit.js

@@ -0,0 +1,53 @@
+/**
+ * vector-cortex/ledger/emit.ts — VC1A ledger emit seam.
+ *
+ * The single structured-event surface for the EventV2 ledger path. It mirrors
+ * the VC0B replay emit seam (`src/vector-cortex/replay/emit.ts`): the same
+ * non-fatal, structured-JSON `ts`+`event` contract (`src/log.ts` LogEntry),
+ * delivered through an injected emit callback so it stays pi-agnostic,
+ * deterministically testable, and network-free (PREVENT-PI-004).
+ *
+ * Carries only the two EventV2 events:
+ *   - vector_cortex_event_decoded          (a V2 occurrence was byte-decoded)
+ *   - vector_cortex_event_validation_failed (a V2 conformity check failed)
+ *
+ * Flag gating: this is VC1A's single real consumer of `VC1A_ENABLED()`. When the
+ * flag is OFF the reporter emits NOTHING (zero observability writes) — the
+ * VC1A mode-C byte-identical behavior — while the codec/validator still operate.
+ * The flag is read per-call so a live toggle takes effect immediately.
+ */
+import { VC1A_ENABLED } from "../../config/vector-cortex.js";
+function safe(fn) {
+    return (event, fields) => {
+        try {
+            fn(event, fields);
+        }
+        catch {
+            /* non-fatal observability — never break the agent loop */
+        }
+    };
+}
+/**
+ * Build a typed reporter over an injected emit callback. Emission is gated on
+ * `VC1A_ENABLED()` — flag OFF means zero ledger observability writes (mode-C
+ * parity). `emit` is optional: absent (or flag off) degrades to a no-op.
+ */
+export function createLedgerReporter(emit) {
+    const fire = safe((event, fields) => {
+        if (VC1A_ENABLED())
+            emit?.(event, fields);
+    });
+    return {
+        eventDecoded(fields) {
+            fire("vector_cortex_event_decoded", fields);
+        },
+        validationFailed(fields) {
+            fire("vector_cortex_event_validation_failed", fields);
+        },
+    };
+}
+/** Export the event names for consumers that match on them. */
+export const LEDGER_EVENTS = [
+    "vector_cortex_event_decoded",
+    "vector_cortex_event_validation_failed",
+];

package/dist/src/vector-cortex/ledger/event-codec.js

@@ -0,0 +1,72 @@
+/**
+ * vector-cortex/ledger/event-codec.ts — EventV2 byte-authority codec, Mode A
+ * (VC1A, TRIAD_RESILIENCE).
+ *
+ * A retains `originalBytes` + a SHA-256 `bytesDigest` and classifies strict
+ * UTF-8 (success) vs invalid-byte content WITHOUT replacement decoding:
+ * `TextDecoder(..., {fatal:true})` either yields text or throws — invalid input
+ * is represented only as `{valid:false, base64}` and is NEVER lossy-replaced.
+ * `canonicalNfc` is computed ONLY as a derived field for valid UTF-8 and is
+ * NEVER used for identity, digest, or byte reconstruction — `decode` returns the
+ * authoritative `originalBytes` exactly.
+ *
+ * Mode B (`./event-codecB.ts`) is a genuinely independent implementation of the
+ * same byte rule; A and B share no subroutine and must agree byte-for-byte.
+ *
+ * Pure/deterministic — no console, no network, no side effects (PREVENT-PI-004).
+ */
+import nodeCrypto from "node:crypto";
+/** Mode-A internal SHA-256 helper (NOT shared with mode B). */
+function digestSha256A(bytes) {
+    const hex = nodeCrypto.createHash("sha256").update(bytes).digest("hex");
+    return `sha256:${hex}`;
+}
+/** Mode-A internal base64 (NOT shared with mode B). */
+function base64EncodeA(bytes) {
+    return Buffer.from(bytes).toString("base64");
+}
+/**
+ * Strict UTF-8 classification with FATAL decoding (never replaces invalid bytes
+ * with U+FFFD). Returns the decoded text, or `{valid:false, base64}`.
+ */
+export function classifyUtf8(bytes) {
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        return { valid: true, text };
+    }
+    catch {
+        return { valid: false, base64: base64EncodeA(bytes) };
+    }
+}
+/** Build the Mode-A byte-authority codec. */
+export function createEventCodec() {
+    return {
+        encode(input) {
+            const bytes = input.bytes;
+            const bytesDigest = digestSha256A(bytes);
+            const utf8 = classifyUtf8(bytes);
+            const event = {
+                schema: "event-v2",
+                sessionId: input.sessionId,
+                seq: input.seq,
+                eventId: input.eventId,
+                role: input.role,
+                kind: input.kind,
+                originalBytes: bytes,
+                bytesDigest,
+                utf8,
+                occurredAtMs: input.occurredAtMs,
+            };
+            if (input.toolCallId !== undefined)
+                event.toolCallId = input.toolCallId;
+            // canonicalNfc is a DERIVED search key — valid UTF-8 only, never identity.
+            if (utf8.valid)
+                event.canonicalNfc = utf8.text.normalize("NFC");
+            return event;
+        },
+        decode(event) {
+            return event.originalBytes;
+        },
+        classifyUtf8,
+    };
+}

package/dist/src/vector-cortex/ledger/event-codecB.js

@@ -0,0 +1,76 @@
+/**
+ * vector-cortex/ledger/event-codecB.ts — EventV2 byte-authority codec, Mode B
+ * (VC1A, TRIAD_RESILIENCE).
+ *
+ * B is a GENUINELY independent raw-byte record implementation of the SAME byte
+ * rule as Mode A (`./event-codec.ts`). It shares NO subroutine with A: its own
+ * SHA-256 helper, its own base64 helper, its own strict-UTF-8 classifier, and
+ * its own raw record — the lesson from VC0B-I09 (a mode-B tested against code
+ * identical to A is a tautology). Because the digest of given bytes is a pure
+ * function, two independent implementations MUST agree byte-for-byte; the
+ * acceptance test asserts `bytesDigest` parity across the fixture corpus.
+ *
+ * B retains `originalBytes` + `bytesDigest` and classifies strict UTF-8 with no
+ * lossy replacement; `canonicalNfc` is derived for valid UTF-8 but never used
+ * for identity, digest, or reconstruction.
+ *
+ * Pure/deterministic — no console, no network, no side effects (PREVENT-PI-004).
+ */
+import nodeCrypto from "node:crypto";
+/** Mode-B internal SHA-256 helper (independent of A's — no shared subroutine). */
+function digestSha256B(bytes) {
+    const d = nodeCrypto.createHash("sha256");
+    d.update(bytes);
+    const hex = d.digest("hex");
+    return `sha256:${hex}`;
+}
+/** Mode-B internal base64 (independent of A's). */
+function base64EncodeB(bytes) {
+    let out = "";
+    const buf = Buffer.from(bytes);
+    for (let i = 0; i < buf.length; i += 3) {
+        const b0 = buf[i];
+        const b1 = i + 1 < buf.length ? buf[i + 1] : -1;
+        const b2 = i + 2 < buf.length ? buf[i + 2] : -1;
+        out += CHARS[(b0 >> 2) & 63];
+        out += CHARS[((b0 & 3) << 4) | (b1 < 0 ? 0 : (b1 >> 4) & 15)];
+        if (b1 >= 0)
+            out += CHARS[((b1 & 15) << 2) | (b2 < 0 ? 0 : (b2 >> 6) & 3)];
+        if (b2 >= 0)
+            out += CHARS[b2 & 63];
+    }
+    // Padding (independent reconstruction of standard base64).
+    const pad = (3 - (buf.length % 3)) % 3;
+    for (let i = 0; i < pad; i++)
+        out += "=";
+    return out;
+}
+const CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** Mode-B strict UTF-8 classifier (fatal decode; no replacement). */
+function classifyUtf8B(bytes) {
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        return { valid: true, text };
+    }
+    catch {
+        return { valid: false, base64: base64EncodeB(bytes) };
+    }
+}
+/** Independently digest + classify raw bytes into a B record. */
+export function recordRawBytesB(bytes) {
+    const bytesDigest = digestSha256B(bytes);
+    const utf8 = classifyUtf8B(bytes);
+    const record = { originalBytes: bytes, bytesDigest, utf8 };
+    if (utf8.valid) {
+        return { originalBytes: bytes, bytesDigest, utf8, canonicalNfc: utf8.text.normalize("NFC") };
+    }
+    return record;
+}
+/**
+ * Independent digest check: recompute the SHA-256 over an EventV2's
+ * `originalBytes` via B's OWN algorithm and compare to the stored digest.
+ * Returns the recomputed digest string (parity-checked by the caller).
+ */
+export function digestCheckB(event) {
+    return digestSha256B(event.originalBytes);
+}

package/dist/src/vector-cortex/ledger/sqlite.js

@@ -0,0 +1,200 @@
+/**
+ * vector-cortex/ledger/sqlite.ts — occurrence-v2 SQLite store, Mode A (VC1B).
+ *
+ * A self-contained, isolated SQLite store (`node:sqlite` `DatabaseSync`) over its
+ * OWN database file — NOT the host `sqlite.db` — so the neutral v2 ledger is a
+ * true independent authority, not a host table. Holds the canonical occurrence
+ * rows plus per-session monotonic seq and the durable contiguous high-water.
+ *
+ * The defect M2 fixes: the host `raw_transcript` table keys on
+ * `(content_hash, session_id)`, so repeated equal bytes at a later turn are
+ * silently dropped. Here the ledger keys occurrences by `(event_id, digest)`
+ * ONLY — equal bytes at a distinct seq/event-id are preserved as separate
+ * occurrences (M2-DUP-001).
+ *
+ * Append enforces, per occurrence: (1) strictly monotonic per-session seq
+ * (EVT_SEQ_REGRESSION otherwise); (2) a tool RESULT names exactly one earlier
+ * call (EVT_TOOL_CALL_MISSING otherwise); (3) exact `(event_id,digest)`
+ * re-appends are acknowledged idempotently, never duplicated.
+ *
+ * Mode A of the VC1B triad: transactional SQLite append. Mode B (`./spool.ts`)
+ * is an independent fsync spool; mode C leaves the host transcript unchanged.
+ *
+ * PREVENT-002: every query is parameterized. PREVENT-011: no `any`.
+ * PREVENT-PI-004: local filesystem only, no network. No console.log.
+ */
+import { DatabaseSync } from "node:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { createHash } from "node:crypto";
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS occurrence_v2 (
+  session       TEXT    NOT NULL,
+  seq           INTEGER NOT NULL,
+  event_id      TEXT    NOT NULL,
+  digest        TEXT    NOT NULL,
+  kind          TEXT    NOT NULL,
+  tool_call_id  TEXT,
+  source_bytes  BLOB,
+  PRIMARY KEY (session, seq),
+  UNIQUE (session, event_id, digest)
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS ledger_high_water (
+  session TEXT PRIMARY KEY,
+  seq     INTEGER NOT NULL
+) STRICT;
+`;
+/** Default digest for a row when the caller omits one (sha256 over bytes). */
+export function ledgerDigest(bytes) {
+    const hex = createHash("sha256").update(bytes).digest("hex");
+    return `sha256:${hex}`;
+}
+/** Open (or reuse) the isolated occurrence-v2 ledger DB handle. */
+export function openOccurrenceStore(dbPath) {
+    const dir = dirname(dbPath);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const db = new DatabaseSync(dbPath);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    db.exec(SCHEMA);
+    return db;
+}
+function rowToOccurrence(row) {
+    return {
+        session: row.session,
+        seq: BigInt(row.seq),
+        eventId: row.event_id,
+        digest: row.digest,
+        kind: row.kind,
+        toolCallId: row.tool_call_id ?? undefined,
+        sourceBytes: row.source_bytes ? Buffer.from(row.source_bytes) : new Uint8Array(0),
+    };
+}
+/** Current durable contiguous high-water for a session (0 when none). */
+export function ledgerHighWater(db, session) {
+    const row = db
+        .prepare(`SELECT seq FROM ledger_high_water WHERE session = @session`)
+        .get({ "@session": session });
+    return row ? BigInt(row.seq) : 0n;
+}
+/** Read all accepted occurrences for a session in ascending (seq,eventId). */
+export function readSessionOccurrences(db, session) {
+    const rows = db
+        .prepare(`SELECT session, seq, event_id, digest, kind, tool_call_id, source_bytes
+       FROM occurrence_v2 WHERE session = @session
+       ORDER BY seq ASC, event_id ASC`)
+        .all({ "@session": session });
+    return rows.map(rowToOccurrence);
+}
+/** Occurrences at or above `fromSeq` (inclusive), ascending. */
+export function readFromSeq(db, session, fromSeq) {
+    const rows = db
+        .prepare(`SELECT session, seq, event_id, digest, kind, tool_call_id, source_bytes
+       FROM occurrence_v2 WHERE session = @session AND seq >= @from
+       ORDER BY seq ASC, event_id ASC`)
+        .all({ "@session": session, "@from": Number(fromSeq) });
+    return rows.map(rowToOccurrence);
+}
+/** Count accepted occurrences for a session. */
+export function countOccurrences(db, session) {
+    const row = db
+        .prepare(`SELECT COUNT(*) AS cnt FROM occurrence_v2 WHERE session = @session`)
+        .get({ "@session": session });
+    return row.cnt;
+}
+/** Whether a `(event_id, digest)` pair is already accepted in a session. */
+export function hasOccurrence(db, session, eventId, digest) {
+    const row = db
+        .prepare(`SELECT 1 AS hit FROM occurrence_v2
+       WHERE session = @session AND event_id = @event_id AND digest = @digest LIMIT 1`)
+        .get({ "@session": session, "@event_id": eventId, "@digest": digest });
+    return row !== undefined;
+}
+/** The stored occurrence matching a `(event_id, digest)` pair, or undefined. */
+function findOccurrence(db, session, eventId, digest) {
+    const row = db
+        .prepare(`SELECT session, seq, event_id, digest, kind, tool_call_id, source_bytes
+       FROM occurrence_v2
+       WHERE session = @session AND event_id = @event_id AND digest = @digest LIMIT 1`)
+        .get({ "@session": session, "@event_id": eventId, "@digest": digest });
+    return row ? rowToOccurrence(row) : undefined;
+}
+/** Whether a prior call row with the given eventId exists in the session. */
+function hasCallRef(db, session, eventId) {
+    const row = db
+        .prepare(`SELECT 1 AS hit FROM occurrence_v2
+       WHERE session = @session AND event_id = @event_id LIMIT 1`)
+        .get({ "@session": session, "@event_id": eventId });
+    return row !== undefined;
+}
+/**
+ * Append one occurrence within a transaction. Enforces monotonic seq, tool-call
+ * reference completeness, and `(event_id,digest)` idempotent ack. Returns the
+ * accepted row or a deterministic failure code.
+ */
+export function appendOccurrence(db, input) {
+    const digest = input.digest ?? ledgerDigest(input.sourceBytes);
+    const occurrence = {
+        session: input.session,
+        seq: input.seq,
+        eventId: input.eventId,
+        digest,
+        kind: input.kind,
+        toolCallId: input.toolCallId,
+        sourceBytes: input.sourceBytes,
+    };
+    // (3) exact (event_id,digest) re-append is acknowledged idempotently, WITHOUT
+    // inserting a new row. Return the EXISTING stored occurrence (its real seq) —
+    // not the caller's input — so a journal record written from this result carries
+    // the existing seq, which always corresponds to a real occurrence_v2 row (Q01:
+    // never a phantom journal row at a seq with no backing occurrence).
+    const existing = findOccurrence(db, input.session, input.eventId, digest);
+    if (existing) {
+        return { ok: true, occurrence: existing };
+    }
+    // (1) monotonic seq: must be exactly the next expected seq (highWater+1).
+    const hw = ledgerHighWater(db, input.session);
+    if (input.seq !== hw + 1n) {
+        return { ok: false, code: "EVT_SEQ_REGRESSION", rejected: occurrence };
+    }
+    // (2) a tool RESULT names exactly one earlier call in the same session.
+    if (input.toolCallId !== undefined && input.toolCallId !== "") {
+        if (!hasCallRef(db, input.session, input.toolCallId)) {
+            return { ok: false, code: "EVT_TOOL_CALL_MISSING", rejected: occurrence };
+        }
+    }
+    // Accept: insert the row and advance the per-session high-water atomically.
+    db.exec("SAVEPOINT mc_ledger");
+    try {
+        db.prepare(`INSERT INTO occurrence_v2 (session, seq, event_id, digest, kind, tool_call_id, source_bytes)
+       VALUES (@session, @seq, @event_id, @digest, @kind, @tool_call_id, @source_bytes)`).run({
+            "@session": input.session,
+            "@seq": Number(input.seq),
+            "@event_id": input.eventId,
+            "@digest": digest,
+            "@kind": input.kind,
+            "@tool_call_id": input.toolCallId ?? null,
+            "@source_bytes": Buffer.from(input.sourceBytes),
+        });
+        db.prepare(`INSERT INTO ledger_high_water (session, seq) VALUES (@session, @seq)
+       ON CONFLICT(session) DO UPDATE SET seq = excluded.seq`).run({ "@session": input.session, "@seq": Number(input.seq) });
+        db.exec("RELEASE mc_ledger");
+    }
+    catch (e) {
+        db.exec("ROLLBACK TO mc_ledger");
+        db.exec("RELEASE mc_ledger");
+        throw e;
+    }
+    return { ok: true, occurrence };
+}
+/** Append a batch; each occurrence reports its own result. */
+export function appendOccurrenceBatch(db, inputs) {
+    return inputs.map((input) => appendOccurrence(db, input));
+}
+/** Diagnostic: total accepted occurrences across all sessions. */
+export function countAllOccurrences(db) {
+    const row = db.prepare(`SELECT COUNT(*) AS cnt FROM occurrence_v2`).get();
+    return row.cnt;
+}

package/dist/src/vector-cortex/ledger/store.js

@@ -0,0 +1,184 @@
+/**
+ * vector-cortex/ledger/store.ts — VC1B capability-separated ledger contracts.
+ *
+ * Owns `LedgerReader` / `LedgerWriter` / `LedgerAdmin` and `CompatJournalV1`.
+ * The ledger is append-only, seq is monotonic per session, a tool RESULT names
+ * exactly one earlier call in the same session, and duplicates are identified by
+ * `(eventId, digest)` only (two occurrences may share bytes at distinct seq).
+ *
+ * Capability gating mirrors the host `asReader/asWriter/asAdmin` pattern: a
+ * consumer receives ONLY what it needs. Dashboard GET receives `LedgerReader`;
+ * only ingestion receives `LedgerWriter`; only the migration coordinator
+ * receives `LedgerAdmin`. This keeps the neutral byte-authority ledger closed to
+ * anything but the sanctioned channels (CONTRACTS §Store and migration
+ * contracts).
+ *
+ * Pure type/schema definitions + small pure predicates. No storage, no console,
+ * no network, no side effects (PREVENT-PI-004 / PREVENT-011).
+ */
+import { VC1B_ENABLED } from "../../config/vector-cortex.js";
+import { openOccurrenceStore, appendOccurrence, ledgerHighWater, readSessionOccurrences, readFromSeq, countOccurrences, hasOccurrence, } from "./sqlite.js";
+import { initCompatJournal, createCompatJournal, journalPhase, } from "./compat-journal.js";
+import { m2Copy, m2Validate, m2Switch, } from "../migrations/occurrence-v2.js";
+/** The token that gates closures to a single capability (PREVENT-011-free). */
+const _capability = Symbol("mc-ledger-capability");
+/**
+ * Create the capability-separated occurrence-v2 ledger over its OWN isolated
+ * SQLite DB. `emit` is optional; occurrence-appended and compat-switch-committed
+ * events are only emitted when VC1B_ENABLED() and an emitter is supplied (mode-C
+ * parity: flag OFF / no emitter => zero observability writes).
+ *
+ * Normalization: `stateDir` gives the standard daemon location
+ * `<stateDir>/vector-cortex/occurrence-v2.db`; a bare `dbPath` overrides it
+ * (tests/rehearsal isolate the ledger). The compat journal shares the same DB
+ * so a v2 append + its journal record commit atomically.
+ */
+export function createLedgerStore(opts, emit) {
+    const dbPath = "dbPath" in opts
+        ? opts.dbPath
+        : `${opts.stateDir}/vector-cortex/occurrence-v2.db`;
+    const db = openOccurrenceStore(dbPath);
+    initCompatJournal(db);
+    const compat = createCompatJournal(db);
+    const fire = (event, fields) => {
+        if (!VC1B_ENABLED())
+            return;
+        try {
+            emit?.(event, fields);
+        }
+        catch {
+            /* non-fatal observability — never break the agent loop */
+        }
+    };
+    const asReader = () => ({
+        kind: "LedgerReader",
+        [_capability]: "reader",
+        highWater: (session) => ledgerHighWater(db, session),
+        readSession: (session) => readSessionOccurrences(db, session),
+        readFrom: (session, fromSeq) => readFromSeq(db, session, fromSeq),
+        count: (session) => countOccurrences(db, session),
+        hasOccurrence: (session, eventId, digest) => hasOccurrence(db, session, eventId, digest),
+    });
+    const asWriter = () => ({
+        kind: "LedgerWriter",
+        [_capability]: "writer",
+        append(input) {
+            // The occurrence insert and its compat-journal record commit atomically
+            // inside one nested savepoint (CONTRACTS §Store: atomically appends).
+            db.exec("SAVEPOINT mc_ledger_app");
+            try {
+                const result = appendOccurrence(db, input);
+                if (result.ok) {
+                    compat.record({
+                        occurrence: result.occurrence,
+                        legacyProjection: legacyProjectionOf(result.occurrence),
+                    });
+                }
+                if (result.ok) {
+                    db.exec("RELEASE mc_ledger_app");
+                    fire("vector_cortex_occurrence_appended", {
+                        session: result.occurrence.session,
+                        seq: result.occurrence.seq.toString(),
+                        eventId: result.occurrence.eventId,
+                        digest: result.occurrence.digest,
+                        kind: result.occurrence.kind,
+                    });
+                }
+                else {
+                    db.exec("ROLLBACK TO mc_ledger_app");
+                    db.exec("RELEASE mc_ledger_app");
+                }
+                return result;
+            }
+            catch (e) {
+                db.exec("ROLLBACK TO mc_ledger_app");
+                db.exec("RELEASE mc_ledger_app");
+                throw e;
+            }
+        },
+        appendBatch(inputs) {
+            const out = [];
+            for (const input of inputs)
+                out.push(this.append(input));
+            return out;
+        },
+    });
+    const asAdmin = () => ({
+        kind: "LedgerAdmin",
+        [_capability]: "admin",
+        compat,
+        migrateOccurrenceV2() {
+            // copy => validate => switch; resumable & idempotent. The M2 host wraps
+            // the live DB + journal so every phase transition advances the SAME
+            // singleton journal state machine (prepared→copied→validated→switched).
+            const unrepresentable = compat.prepare().length;
+            const mig = migrateHost(db, compat);
+            m2Copy(mig);
+            const v = m2Validate(mig);
+            if (v.ok) {
+                m2Switch(mig);
+                fire("vector_cortex_compat_switch_committed", {
+                    session: "all",
+                    unrepresentable,
+                });
+            }
+            return { ok: v.ok, codes: v.codes };
+        },
+    });
+    return { reader: asReader, writer: asWriter, admin: asAdmin, close: () => db.close() };
+}
+/**
+ * Lossless legacy projection for a v2 occurrence: its identity envelope plus
+ * base64 source bytes. Returns null (→ journal `unrepresentable` marker) when the
+ * source bytes do not form valid UTF-8, which the legacy pipeline cannot round-trip
+ * losslessly — those rows are listed rather than silently coerced (MIG-DOWN-003).
+ */
+function legacyProjectionOf(occ) {
+    const source = Buffer.from(occ.sourceBytes);
+    try {
+        new TextDecoder("utf-8", { fatal: true }).decode(source);
+    }
+    catch {
+        return null;
+    }
+    return JSON.stringify({
+        session: occ.session,
+        eventId: occ.eventId,
+        kind: occ.kind,
+        digest: occ.digest,
+        source: source.toString("base64"),
+    });
+}
+/** Build an M2Host over the live ledger DB + journal (for migrateOccurrenceV2). */
+function migrateHost(db, journal) {
+    let staged = null;
+    return {
+        db,
+        phase: () => journalPhase(db),
+        journalActive: () => journal.active(),
+        journalRows: () => journalRowsOf(db),
+        writeStagedLegacy: (rows) => {
+            staged = rows;
+            journal.copied();
+        },
+        stagedLegacy: () => staged,
+        validateStaged: () => journal.validate(),
+        switchLegacy: () => journal.switched(),
+    };
+}
+/** Read the journaled occurrences as legacy-export rows. */
+function journalRowsOf(db) {
+    const rows = db
+        .prepare(`SELECT session, seq, event_id, digest, kind, legacy_projection, unrepresentable
+       FROM compat_journal_v1 ORDER BY session ASC, seq ASC`)
+        .all();
+    return rows.map((r) => ({
+        session: r.session,
+        seq: BigInt(r.seq),
+        eventId: r.event_id,
+        digest: r.digest,
+        kind: r.kind,
+        legacyProjection: r.legacy_projection,
+        unrepresentable: r.unrepresentable === 1,
+    }));
+}

package/dist/src/vector-cortex/ledger/types.js

@@ -0,0 +1,52 @@
+/**
+ * vector-cortex/ledger/types.ts — EventV2 / EventCodec byte-authority contract
+ * types, validation result codes, and the registered EVT conformance ID range.
+ *
+ * Owned by VC1A (canonical byte events). Consumes only reviewer-accepted
+ * predecessor contracts and [common contracts](../../CONTRACTS.md §EventV2),
+ * which are NORMATIVE here. `originalBytes` and its SHA-256 digest are the byte
+ * authority; strict UTF-8 classification is never lossy; `canonicalNfc` is a
+ * DERIVED comparison/search key only (never identity, digest, or reconstruction).
+ *
+ * Pure type/schema definitions + a short pure digest/classify predicate runtime
+ * (validator codes). No network, no side effects (PREVENT-PI-004 / PREVENT-011).
+ */
+/**
+ * Registered EVT conformance ID range (EVT-001..030). The acceptance test reads
+ * these rows from the v2 manifest and asserts each returns its manifest bytes or
+ * exactly its listed failure code. Mirrors CUT_IDS / M3_IDS in replay/types.ts.
+ * EVT-001..015 are owned by VC1A (codec/validator); EVT-016..030 are owned by
+ * VC1B (occurrence ledger, see ledger/store.ts).
+ */
+export const EVT_IDS = [
+    "EVT-001",
+    "EVT-002",
+    "EVT-003",
+    "EVT-004",
+    "EVT-005",
+    "EVT-006",
+    "EVT-007",
+    "EVT-008",
+    "EVT-009",
+    "EVT-010",
+    "EVT-011",
+    "EVT-012",
+    "EVT-013",
+    "EVT-014",
+    "EVT-015",
+    "EVT-016",
+    "EVT-017",
+    "EVT-018",
+    "EVT-019",
+    "EVT-020",
+    "EVT-021",
+    "EVT-022",
+    "EVT-023",
+    "EVT-024",
+    "EVT-025",
+    "EVT-026",
+    "EVT-027",
+    "EVT-028",
+    "EVT-029",
+    "EVT-030",
+];