@astrosheep/square 0.3.86 → 0.3.88

package/dist/host-ledger-sqlite.js

@@ -1,368 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { SquareError, nameKey } from './model.js';
-import { inSqliteTransaction, retrySqliteBusy } from './sqlite-transaction.js';
-export const LEDGER_FILENAME = 'host-ledger.sqlite';
-export const LEDGER_APPLICATION_ID = 0x5351484c;
-export const LEDGER_VERSION = 2;
-export const LEDGER_RETENTION = 7 * 86400000;
-const tables = { presence: 'host_presence', evidence: 'host_evidence' };
-const columns = {
-    presence: ['location_key', 'participant_key', 'session_key', 'channel_key', 'effective_at'],
-    evidence: ['location_key', 'participant_key', 'session_key', 'activity_key', 'kind', 'outcome', 'claim_token_key', 'effective_at'],
-};
-const indexes = {
-    host_presence_identity: ['host_presence', 'location_key', 'participant_key', 'seq'],
-    host_presence_session: ['host_presence', 'session_key', 'seq'],
-    host_presence_time: ['host_presence', 'effective_at'],
-    host_evidence_attention: ['host_evidence', 'location_key', 'participant_key', 'activity_key', 'kind', 'session_key', 'seq'],
-    host_evidence_kind_session: ['host_evidence', 'kind', 'session_key', 'seq'],
-    host_evidence_session: ['host_evidence', 'session_key', 'seq'],
-    host_evidence_token: ['host_evidence', 'location_key', 'participant_key', 'activity_key', 'session_key', 'claim_token_key', 'seq'],
-    host_evidence_outcome_time: ['host_evidence', 'outcome', 'effective_at'],
-    host_evidence_time: ['host_evidence', 'effective_at'],
-    host_evidence_native_token: ['host_evidence', 'session_key', 'claim_token_key', 'seq'],
-};
-const tableSchema = {
-    host_meta: 'CREATE TABLE host_meta (id INTEGER PRIMARY KEY CHECK(id=1), presence_revision INTEGER NOT NULL, evidence_revision INTEGER NOT NULL)',
-    host_presence: 'CREATE TABLE host_presence (seq INTEGER PRIMARY KEY AUTOINCREMENT, location_key TEXT NOT NULL, participant_key TEXT NOT NULL, session_key TEXT NOT NULL, channel_key TEXT NOT NULL, effective_at REAL NOT NULL, row_json TEXT NOT NULL)',
-    host_evidence: 'CREATE TABLE host_evidence (seq INTEGER PRIMARY KEY AUTOINCREMENT, location_key TEXT NOT NULL, participant_key TEXT NOT NULL, session_key TEXT NOT NULL, activity_key TEXT NOT NULL, kind TEXT NOT NULL, outcome TEXT NOT NULL, claim_token_key TEXT, effective_at REAL NOT NULL, row_json TEXT NOT NULL)',
-    host_native_tokens: "CREATE TABLE host_native_tokens (harness TEXT NOT NULL CHECK(harness='claude'), session_key TEXT NOT NULL, token_key TEXT NOT NULL, PRIMARY KEY(harness,session_key,token_key)) WITHOUT ROWID",
-};
-const versionTwoNames = new Set(['host_native_tokens', 'host_evidence_native_token']);
-const retainedEvidence = "(kind='wake' AND (outcome IN ('accepted','unknown','dispatching') OR COALESCE(json_extract(row_json,'$.nativeDelivery.harness'),'')='claude'))";
-function validToken(token) { return typeof token === 'string' && /^[a-zA-Z0-9-]+$/.test(token); }
-function indexSql(name, [table, ...fields]) {
-    return `CREATE INDEX ${name} ON ${table} (${fields.join(',')})`;
-}
-function invalid(message) { return new Error(`Invalid host ledger: ${message}`); }
-function key(value) { return JSON.stringify(value); }
-/** The complete record remains authority; these are only reproducible lookup projections. */
-export function ledgerRecordColumns(kind, input) {
-    const row = input;
-    if (!row || Array.isArray(row) || row.v !== 1)
-        throw invalid('record version');
-    for (const field of ['location', 'participant', 'session', ...(kind === 'presence' ? ['channel'] : ['activity', 'kind', 'outcome'])]) {
-        if (typeof row[field] !== 'string')
-            throw invalid(`record ${field}`);
-    }
-    if (kind === 'evidence' && row.claimToken !== undefined && typeof row.claimToken !== 'string')
-        throw invalid('record claimToken');
-    const at = row.at ?? row.updatedAt;
-    if (typeof at !== 'number' || !Number.isFinite(at))
-        throw invalid('record time');
-    return {
-        location_key: key(row.location), participant_key: key(nameKey(row.participant)), session_key: key(row.session),
-        ...(kind === 'presence' ? { channel_key: key(row.channel) } : {
-            activity_key: key(row.activity), kind: row.kind, outcome: row.outcome,
-            claim_token_key: row.claimToken === undefined ? null : key(row.claimToken),
-        }), effective_at: at,
-    };
-}
-export function initializeLedger(db) {
-    db.exec(`PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL;
-    PRAGMA application_id=${LEDGER_APPLICATION_ID}; PRAGMA user_version=${LEDGER_VERSION};`);
-    initializeLedgerSchema(db);
-}
-export function setLedgerRevisions(db, revisions) {
-    if (![revisions.presence, revisions.evidence].every((n) => Number.isSafeInteger(n) && n >= 0))
-        throw invalid('revisions');
-    db.prepare('UPDATE host_meta SET presence_revision=?,evidence_revision=? WHERE id=1').run(revisions.presence, revisions.evidence);
-}
-export function insertLedgerRecord(db, kind, row) {
-    const derived = ledgerRecordColumns(kind, row);
-    db.prepare(`INSERT INTO ${tables[kind]} (${columns[kind].join(',')},row_json) VALUES (${columns[kind].map(() => '?').join(',')},?)`)
-        .run(...columns[kind].map((column) => derived[column]), JSON.stringify(row));
-}
-export function ledgerRevisions(db) {
-    const rows = db.prepare('SELECT id,presence_revision,evidence_revision FROM host_meta').all();
-    if (rows.length !== 1 || rows[0].id !== 1 || ![rows[0].presence_revision, rows[0].evidence_revision].every((n) => typeof n === 'number' && Number.isSafeInteger(n) && n >= 0))
-        throw invalid('revisions');
-    return { presence: rows[0].presence_revision, evidence: rows[0].evidence_revision };
-}
-export function validateLedger(db) { validateLedgerAtVersion(db, LEDGER_VERSION); }
-function validateLedgerAtVersion(db, version) {
-    validateLedgerHeader(db, version);
-    if (db.prepare('PRAGMA journal_mode').get()?.journal_mode !== 'delete')
-        throw invalid('journal mode');
-    const expected = new Map([...Object.entries(tableSchema), ...Object.entries(indexes).map(([name, fields]) => [name, indexSql(name, fields)])].filter(([name]) => version >= 2 || !versionTwoNames.has(name)));
-    const schema = db.prepare("SELECT name,sql FROM sqlite_schema WHERE name NOT LIKE 'sqlite_%'").all();
-    const normalize = (sql) => sql.replace(/\s+/g, '').replace(/;$/, '');
-    if (schema.length !== expected.size || schema.some((row) => typeof row.sql !== 'string' || !expected.has(row.name) || normalize(row.sql) !== normalize(expected.get(row.name))))
-        throw invalid('schema or indexes');
-    ledgerRevisions(db);
-}
-export function verifyLedger(db) {
-    return verifyLedgerAtVersion(db, LEDGER_VERSION);
-}
-function verifyLedgerAtVersion(db, version) {
-    validateLedgerAtVersion(db, version);
-    const integrity = db.prepare('PRAGMA integrity_check').all();
-    if (integrity.length !== 1 || integrity[0].integrity_check !== 'ok')
-        throw invalid('integrity check failed');
-    const counts = { presence: 0, evidence: 0 };
-    for (const kind of ['presence', 'evidence']) {
-        for (const stored of db.prepare(`SELECT * FROM ${tables[kind]} ORDER BY seq ASC`).iterate()) {
-            let row;
-            try {
-                row = JSON.parse(stored.row_json);
-            }
-            catch {
-                throw invalid('record JSON');
-            }
-            const derived = ledgerRecordColumns(kind, row);
-            if (!Number.isSafeInteger(stored.seq) || stored.seq < 1 || columns[kind].some((column) => stored[column] !== derived[column]))
-                throw invalid('record projections');
-            counts[kind] += 1;
-        }
-    }
-    if (version >= 2) {
-        for (const row of db.prepare('SELECT harness,session_key,token_key FROM host_native_tokens').iterate()) {
-            try {
-                const session = JSON.parse(row.session_key), token = JSON.parse(row.token_key);
-                if (row.harness !== 'claude' || typeof session !== 'string' || !session.length || !validToken(token)
-                    || key(session) !== row.session_key || key(token) !== row.token_key)
-                    throw invalid('native token codec');
-            }
-            catch {
-                throw invalid('native token codec');
-            }
-        }
-    }
-    const revision = ledgerRevisions(db);
-    if ((counts.presence && !revision.presence) || (counts.evidence && !revision.evidence))
-        throw invalid('records without revision');
-    return { ...counts, presenceRevision: revision.presence, evidenceRevision: revision.evidence };
-}
-function inspectLegacyRoot(root) {
-    return fs.existsSync(path.join(root, 'presence.ndjsonl')) || fs.existsSync(path.join(root, 'evidence.ndjsonl'));
-}
-/** Read the file-type stamp and format version without making the runtime authority. */
-export function inspectLedgerIdentity(db) {
-    const application = db.prepare('PRAGMA application_id').get().application_id;
-    const version = db.prepare('PRAGMA user_version').get().user_version;
-    if (application !== LEDGER_APPLICATION_ID)
-        return 'unrelated';
-    if (version === LEDGER_VERSION)
-        return 'current';
-    if (version === 1)
-        return 'old-sqlite';
-    return 'unsupported';
-}
-/** Explicit offline migration only; the caller owns the write transaction. Preserve all records and revisions. */
-export function upgradeLedger(db) {
-    if (db.prepare('PRAGMA user_version').get()?.user_version === LEDGER_VERSION) {
-        verifyLedger(db);
-        return false;
-    }
-    verifyLedgerAtVersion(db, 1);
-    db.exec(tableSchema.host_native_tokens);
-    db.exec(indexSql('host_evidence_native_token', indexes.host_evidence_native_token));
-    db.exec(`PRAGMA user_version=${LEDGER_VERSION}`);
-    verifyLedger(db);
-    return true;
-}
-function exists(file) { try {
-    fs.statSync(file);
-    return true;
-}
-catch (error) {
-    if (error.code === 'ENOENT')
-        return false;
-    throw error;
-} }
-export function migrationRequired(root) {
-    return new SquareError('invalid_args', `Host ledger at ${root} needs offline migration.\nStop sessions and MCP services using it, back it up, then migrate and verify from the same environment before restarting.`, { reason: 'migration_required', ledgerRoot: root });
-}
-/** Compact runtime framing. Full schema, projections and integrity belong to explicit verify. */
-function validateLedgerHeader(db, version = LEDGER_VERSION) {
-    if (db.prepare('PRAGMA application_id').get()?.application_id !== LEDGER_APPLICATION_ID)
-        throw invalid('unrelated identity.');
-    if (db.prepare('PRAGMA user_version').get()?.user_version !== version)
-        throw invalid('unsupported format version.');
-}
-/** The runtime's only upgrade door: a supported old ledger is pointed at explicit migration. */
-function runtimeLedgerHeader(db, root) {
-    try {
-        validateLedgerHeader(db);
-    }
-    catch (error) {
-        if (inspectLedgerIdentity(db) === 'old-sqlite')
-            throw migrationRequired(root);
-        throw error;
-    }
-}
-/** Publish new empty authority only. Never initialize or replace an existing destination. */
-function createEmptyLedger(root) {
-    fs.mkdirSync(root, { recursive: true });
-    try {
-        fs.writeFileSync(path.join(root, '.gitignore'), '*\n', { flag: 'wx' });
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-    }
-    const temporary = path.join(root, `.host-ledger.${process.pid}.${randomUUID()}.tmp`);
-    let db;
-    try {
-        fs.closeSync(fs.openSync(temporary, 'wx', 0o600));
-        db = new DatabaseSync(temporary);
-        initializeLedger(db);
-        db.close();
-        db = undefined;
-        try {
-            fs.linkSync(temporary, path.join(root, LEDGER_FILENAME));
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST')
-                throw error;
-        }
-    }
-    finally {
-        db?.close();
-        fs.rmSync(temporary, { force: true });
-    }
-}
-/** Never create authority on a read, or silently replace legacy authority on a write. */
-async function openLedger(root, write, signal) {
-    const file = path.join(root, LEDGER_FILENAME);
-    if (!exists(file)) {
-        if (inspectLegacyRoot(root))
-            throw migrationRequired(root);
-        if (!write)
-            return undefined;
-        if (signal?.aborted)
-            throw signal.reason;
-        createEmptyLedger(root);
-    }
-    const uri = pathToFileURL(file);
-    uri.searchParams.set('mode', write ? 'rw' : 'ro');
-    const db = new DatabaseSync(uri.href);
-    try {
-        await retrySqliteBusy(() => db.exec('PRAGMA busy_timeout=0; PRAGMA synchronous=FULL'), signal);
-        return db;
-    }
-    catch (error) {
-        db.close();
-        throw error;
-    }
-}
-function initializeLedgerSchema(db) {
-    for (const sql of Object.values(tableSchema))
-        db.exec(sql);
-    db.exec('INSERT INTO host_meta VALUES(1,0,0)');
-    for (const [name, fields] of Object.entries(indexes))
-        db.exec(indexSql(name, fields));
-}
-function visibility(kind, now, includeFuture, includeExpired) {
-    const durable = kind === 'evidence' ? ` OR ${retainedEvidence}` : '';
-    const sql = includeExpired ? '1' : `(effective_at>=?${durable})`;
-    const args = includeExpired ? [] : [now - LEDGER_RETENTION];
-    if (!includeFuture)
-        args.push(now);
-    return { sql: `${sql}${includeFuture ? '' : ' AND effective_at<=?'}`, args };
-}
-/** Transaction-local storage rows; sequence coordinates never cross HostLedgerPort. */
-export class LedgerTransaction {
-    db;
-    changed = new Set();
-    constructor(db) {
-        this.db = db;
-    }
-    presence(input, now, includeFuture = false) {
-        return this.select('presence', input, now, includeFuture);
-    }
-    evidence(input, now, includeFuture = false) {
-        return this.select('evidence', input, now, includeFuture);
-    }
-    select(kind, input, now, includeFuture) {
-        const visible = visibility(kind, now, includeFuture, kind === 'evidence' && input.includeExpired === true), where = [visible.sql], args = visible.args;
-        for (const [field, column] of Object.entries({ location: 'location_key', participant: 'participant_key', session: 'session_key', ...(kind === 'evidence' ? { activity: 'activity_key', kind: 'kind', claimToken: 'claim_token_key' } : { channel: 'channel_key' }) })) {
-            const value = input[field];
-            if (value !== undefined) {
-                where.push(`${column}=?`);
-                args.push(column === 'kind' ? value : key(field === 'participant' ? nameKey(value) : value));
-            }
-        }
-        if (kind === 'evidence' && input.includeReleased !== true)
-            where.push("outcome<>'released'");
-        return this.db.prepare(`SELECT seq,row_json FROM ${tables[kind]} WHERE ${where.join(' AND ')} ORDER BY seq ASC`).all(...args).map((stored) => ({ seq: stored.seq, record: JSON.parse(stored.row_json) }));
-    }
-    /** Both halves of recognition are read in the enclosing SQLite snapshot, with indexed session/token predicates. */
-    nativeTokens(input) {
-        const tokens = [...new Set(input.tokens)], encoded = JSON.stringify(tokens.map(key));
-        const deliveries = this.db.prepare("SELECT row_json FROM host_evidence WHERE session_key=? AND claim_token_key IN (SELECT value FROM json_each(?)) AND kind='wake' AND json_extract(row_json,'$.nativeDelivery.harness')='claude' ORDER BY seq ASC")
-            .all(key(input.session), encoded).map(row => JSON.parse(row.row_json));
-        const retired = new Set(this.db.prepare('SELECT token_key FROM host_native_tokens WHERE harness=? AND session_key=? AND token_key IN (SELECT value FROM json_each(?))')
-            .all(input.harness, key(input.session), encoded).map(row => row.token_key));
-        return { deliveries, retired: tokens.filter(token => retired.has(key(token))) };
-    }
-    /** Called only after exact-record CAS. No housekeeping of unrelated rows belongs here. */
-    retireEvidence(row) {
-        const record = row.record;
-        if (record.outcome === 'dispatching')
-            return false;
-        if (record.nativeDelivery?.harness === 'claude') {
-            const native = record.nativeDelivery;
-            if (!record.session || !validToken(record.claimToken) || typeof native.payload !== 'string' || !native.payload.length
-                || typeof native.endpoint !== 'string' || !native.endpoint.length || !Number.isSafeInteger(native.epoch) || native.epoch < 0)
-                return false;
-            this.db.prepare("INSERT OR IGNORE INTO host_native_tokens(harness,session_key,token_key) VALUES('claude',?,?)")
-                .run(key(record.session), key(record.claimToken));
-        }
-        this.remove('evidence', [row]);
-        return true;
-    }
-    insert(kind, row) { insertLedgerRecord(this.db, kind, row); this.changed.add(kind); }
-    replace(kind, seq, row) {
-        const derived = ledgerRecordColumns(kind, row);
-        const result = this.db.prepare(`UPDATE ${tables[kind]} SET ${columns[kind].map((column) => `${column}=?`).join(',')},row_json=? WHERE seq=?`).run(...columns[kind].map((column) => derived[column]), JSON.stringify(row), seq);
-        if (result.changes)
-            this.changed.add(kind);
-    }
-    remove(kind, rows) {
-        const statement = this.db.prepare(`DELETE FROM ${tables[kind]} WHERE seq=?`);
-        for (const row of rows)
-            if (statement.run(row.seq).changes)
-                this.changed.add(kind);
-    }
-    /** Only invoke at the point where the former implementation published a mutation. */
-    publish(kind, now) {
-        const durable = kind === 'evidence' ? ` AND NOT ${retainedEvidence}` : '';
-        if (this.db.prepare(`DELETE FROM ${tables[kind]} WHERE effective_at<?${durable}`).run(now - LEDGER_RETENTION).changes)
-            this.changed.add(kind);
-    }
-    commitRevisions() {
-        for (const kind of this.changed)
-            this.db.exec(`UPDATE host_meta SET ${kind}_revision=${kind}_revision+1 WHERE id=1`);
-    }
-}
-export async function withLedger(root, write, select, absent, signal) {
-    const db = await openLedger(root, write, signal);
-    if (!db)
-        return absent;
-    try {
-        return await inSqliteTransaction(db, write, () => runtimeLedgerHeader(db, root), () => {
-            const rows = new LedgerTransaction(db), result = select(rows);
-            rows.commitRevisions();
-            return result;
-        }, signal);
-    }
-    finally {
-        db.close();
-    }
-}
-export async function readLedgerRevisions(root, signal) {
-    const db = await openLedger(root, false, signal);
-    if (!db)
-        return undefined;
-    try {
-        return await inSqliteTransaction(db, false, () => runtimeLedgerHeader(db, root), () => ledgerRevisions(db), signal);
-    }
-    finally {
-        db.close();
-    }
-}

package/dist/host-ledger.d.ts

@@ -1,195 +0,0 @@
-import type { WakeRouteKind } from './model.js';
-import type { HarnessSessionChannel } from './participant-identity.js';
-export type PresenceChannel = HarnessSessionChannel | 'unknown';
-export interface PresenceRecord {
-    readonly location: string;
-    readonly participant: string;
-    readonly session: string;
-    readonly channel: PresenceChannel;
-    readonly updatedAt?: number;
-    readonly epoch?: number;
-    readonly cancelledThrough?: number;
-}
-export type PresenceKey = Pick<PresenceRecord, 'location' | 'participant' | 'session' | 'channel'>;
-export interface PresenceLookup {
-    readonly location?: string;
-    readonly participant?: string;
-    readonly session?: string;
-    readonly now?: number;
-}
-export type PresenceResult = {
-    readonly status: 'ensured';
-    readonly record: PresenceRecord;
-} | {
-    readonly status: 'degraded';
-    readonly record: PresenceRecord;
-    readonly error: unknown;
-};
-export type PresenceClaimResult = {
-    readonly status: 'acquired' | 'owned';
-    readonly record: PresenceRecord;
-} | {
-    readonly status: 'busy';
-    readonly record: PresenceRecord;
-} | {
-    readonly status: 'degraded';
-    readonly record: PresenceRecord;
-    readonly error: unknown;
-};
-export type NativeDeliveryEvidence = {
-    readonly payload: string;
-    readonly epoch: number;
-} & ({
-    readonly harness: 'claude';
-    readonly endpoint: string;
-    readonly messageId?: string;
-} | {
-    readonly harness: 'opencode';
-    readonly inputId: string;
-});
-export interface NativeDeliveryObservation {
-    readonly eventId: string;
-    readonly messageId: string;
-    readonly state: 'held' | 'released' | 'dropped';
-    readonly reason?: string;
-    readonly observedAt: number;
-}
-export interface EvidenceRecord {
-    readonly nativeObservations?: readonly NativeDeliveryObservation[];
-    readonly bindingEpoch?: number;
-    readonly nativeDelivery?: NativeDeliveryEvidence;
-    readonly location: string;
-    readonly participant: string;
-    readonly session: string;
-    readonly activity: string;
-    readonly kind: 'wake' | 'presentation' | 'lifecycle';
-    readonly outcome: string;
-    readonly at?: number;
-    readonly expiresAt?: number;
-    readonly routeKind?: WakeRouteKind;
-    readonly signature?: string;
-    readonly attemptN?: number;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-    readonly claimToken?: string;
-    readonly ownerPid?: number;
-    readonly unknownSource?: 'interrupted' | 'transport';
-}
-/** Presentation and lifecycle claims only: wake attempts are acquired by claimWakeAttempt. */
-export interface EvidenceClaim {
-    readonly location: string;
-    readonly participant: string;
-    readonly session: string;
-    readonly activity: string;
-    readonly kind: 'presentation' | 'lifecycle';
-    readonly leaseMs: number;
-    readonly now?: number;
-}
-/** Release metadata and includeReleased are diagnostic-only; default evidence reads stay behavior-safe. */
-export interface EvidenceRelease {
-    readonly location: string;
-    readonly participant: string;
-    readonly session: string;
-    readonly activity: string;
-    readonly kind: EvidenceRecord['kind'];
-    readonly claimToken: string;
-    readonly routeKind?: WakeRouteKind;
-    readonly attemptN?: number;
-    readonly signature?: string;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-    readonly now?: number;
-}
-/** includeExpired is maintenance-only: bypass age retention, never future filtering. */
-export interface EvidenceLookup {
-    readonly location?: string;
-    readonly participant?: string;
-    readonly session?: string;
-    readonly activity?: string;
-    readonly kind?: EvidenceRecord['kind'];
-    readonly now?: number;
-    readonly includeReleased?: boolean;
-    readonly includeExpired?: boolean;
-}
-export interface NativeTokenLookup {
-    readonly harness: 'claude';
-    readonly session: string;
-    readonly tokens: readonly string[];
-}
-/** One snapshot of live correlations and recognition-only retired tokens. Neither tokens nor lookup confer authority. */
-export interface NativeTokenResult {
-    readonly deliveries: readonly EvidenceRecord[];
-    readonly retired: readonly string[];
-}
-export interface WakeAttention {
-    readonly squarePath: string;
-    readonly actIndex: number;
-    readonly recipient: string;
-}
-/** One wake attempt row carries attention-wide exclusion and session-specific history. */
-export interface WakeAttemptClaimInput {
-    readonly attention: WakeAttention;
-    readonly session: string;
-    readonly routeKind: WakeRouteKind;
-    readonly leaseMs: number;
-    readonly now?: number;
-}
-export type WakeAttemptClaim = {
-    readonly status: 'acquired';
-    readonly claimToken: string;
-    readonly attemptN: number;
-} | {
-    readonly status: 'busy';
-    readonly record: EvidenceRecord;
-} | {
-    readonly status: 'terminal';
-    readonly record: EvidenceRecord;
-} | {
-    readonly status: 'degraded';
-    readonly error: unknown;
-};
-export interface WakeAttemptLookup {
-    readonly attention?: WakeAttention;
-    readonly session?: string;
-    readonly now?: number;
-}
-export type ClaimResult = {
-    readonly status: 'acquired';
-    readonly claimToken: string;
-} | {
-    readonly status: 'busy' | 'delivered';
-    readonly record: EvidenceRecord;
-} | {
-    readonly status: 'degraded';
-    readonly error: unknown;
-};
-export interface HostLedgerPort {
-    withClaimLock<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
-    claimPresence(input: PresenceRecord, signal?: AbortSignal): Promise<PresenceClaimResult>;
-    ensurePresence(input: PresenceRecord): Promise<PresenceResult>;
-    suppressPresence(input: PresenceRecord, through: number): Promise<boolean>;
-    removePresence(input: PresenceKey): Promise<void>;
-    removePresenceIfUnchanged(input: PresenceRecord): Promise<boolean>;
-    listPresence(input: PresenceLookup): Promise<readonly PresenceRecord[]>;
-    claimEvidence(input: EvidenceClaim): Promise<ClaimResult>;
-    releaseEvidence(input: EvidenceRelease): Promise<void>;
-    appendEvidence(input: EvidenceRecord & {
-        readonly claimToken: string;
-    }): Promise<void>;
-    listEvidence(input: EvidenceLookup): Promise<readonly EvidenceRecord[]>;
-    retireEvidenceIfUnchanged(expected: EvidenceRecord): Promise<boolean>;
-    lookupNativeTokens(input: NativeTokenLookup): Promise<NativeTokenResult>;
-    listWakeAttempts(input?: WakeAttemptLookup): Promise<readonly EvidenceRecord[]>;
-    prepareNativeWake(input: EvidenceRecord & {
-        readonly claimToken: string;
-        readonly routeKind: WakeRouteKind;
-        readonly nativeDelivery: NativeDeliveryEvidence;
-    }): Promise<boolean>;
-    confirmWakeAdmission(input: EvidenceRecord & {
-        readonly claimToken: string;
-    }): Promise<boolean>;
-    observeNativeDelivery(input: EvidenceRecord & {
-        readonly claimToken: string;
-    }, observation: NativeDeliveryObservation): Promise<boolean>;
-    claimWakeAttempt(input: WakeAttemptClaimInput): Promise<WakeAttemptClaim>;
-}

package/dist/host-ledger.js

@@ -1 +0,0 @@
-export {};

package/dist/ledger-maintenance.d.ts

@@ -1,30 +0,0 @@
-import type { HostLedgerPort } from './host-ledger.js';
-/** The two host-ledger capabilities maintenance uses; no parallel ledger contract is owned here. */
-type MaintenanceLedger = Pick<HostLedgerPort, 'listEvidence' | 'retireEvidenceIfUnchanged'>;
-export interface LedgerMaintenanceOptions {
-    /** Prove eligible rows without retiring anything. */
-    readonly dryRun?: boolean;
-    readonly now?: number;
-}
-/**
- * Counts are retired rows, not reclaimed bytes: SQLite reuses freed storage without necessarily
- * shrinking its file. Retired Claude correlations leave indefinite recognition tokens; total
- * token count remains unbounded. Maintenance does not run VACUUM.
- */
-export interface LedgerMaintenanceReport {
-    readonly dryRun: boolean;
-    /** Old rows whose closure proof passed; exact-record CAS may still refuse. */
-    readonly eligible: number;
-    /** Rows actually removed by this run; always 0 in a dry run. */
-    readonly retired: number;
-    /** Eligible rows whose full-record compare-and-swap refused; always 0 in a dry run. */
-    readonly casMisses: number;
-    /** Canonical locations whose artifact could not be read; their rows were retained. */
-    readonly unavailableArtifacts: readonly string[];
-}
-/** Maintenance entry: root selection uses the caller's captured environment. */
-export declare function gcHostLedger(options?: LedgerMaintenanceOptions & {
-    readonly env?: NodeJS.ProcessEnv;
-}): Promise<LedgerMaintenanceReport>;
-export declare function maintainHostLedger(ledger: MaintenanceLedger, options?: LedgerMaintenanceOptions): Promise<LedgerMaintenanceReport>;
-export {};