@astrosheep/square 0.3.86 → 0.3.87

package/dist/cli/ledger-command.js

@@ -1,72 +0,0 @@
-import { gcHostLedger } from '../ledger-maintenance.js';
-import { migrateHostLedger, verifyHostLedger } from '../host-ledger-migration.js';
-import { usage } from './context.js';
-function renderReport(report) {
-    const lines = [
-        `host ledger: ${report.status}`,
-        `root: ${report.rootPath}`,
-        `presence: ${report.presence} · evidence: ${report.evidence}`,
-    ];
-    if (report.presenceRevision !== undefined) {
-        lines.push(`revisions: presence ${report.presenceRevision} · evidence ${report.evidenceRevision}`);
-    }
-    if (report.status === 'upgraded')
-        lines.push('SQLite schema upgraded in place; records, order and revisions preserved.');
-    if (report.ready !== undefined)
-        lines.push(`readiness: ${report.ready ? 'ready' : 'not ready'}`);
-    if (report.sources !== undefined) {
-        for (const kind of ['presence', 'evidence']) {
-            const source = report.sources[kind];
-            lines.push(`${kind}.ndjsonl: ${source.records} accepted · ${source.ignored} ignored · ${source.rejected} rejected · sha256 ${source.sha256 ?? 'absent'}`);
-        }
-    }
-    if (report.status === 'legacy') {
-        if (report.ready)
-            lines.push('Stop agent sessions and MCP services using Square with this ledger before conversion.', 'Keep them stopped until migration and verification succeed; then start them with the updated Square version.', 'Next: migrate, then verify.', 'square ledger migrate', 'square ledger verify');
-        else
-            lines.push('Unsafe legacy records; conversion refused. Preserve the sources and resolve the rejected records before retrying verification.');
-    }
-    if (report.status === 'migrated' || report.status === 'upgraded') {
-        lines.push('Keep affected sessions and MCP services stopped until verification succeeds.', 'After verification, start them with the updated Square version.', 'square ledger verify');
-    }
-    return lines.join('\n') + '\n';
-}
-/** Counts only: unreadable locations are summarized, never printed, so no payload or credential can leak. */
-function renderMaintenance(report) {
-    return [
-        `host ledger: gc${report.dryRun ? ' (dry run)' : ''}`,
-        `eligible: ${report.eligible} · retired: ${report.retired} · cas misses: ${report.casMisses}`,
-        `unreadable artifacts: ${report.unavailableArtifacts.length}`,
-        ...(report.dryRun ? ['Dry run: nothing retired; ledger and artifacts unchanged.'] : []),
-        '',
-    ].join('\n');
-}
-export const ledgerCommand = {
-    parse(argv, context) {
-        if (argv[0] === 'gc') {
-            if (argv.length === 1)
-                return { action: 'gc', dryRun: false };
-            if (argv.length === 2 && argv[1] === '--dry-run')
-                return { action: 'gc', dryRun: true };
-            return usage(context.command);
-        }
-        if (argv.length !== 1 || (argv[0] !== 'verify' && argv[0] !== 'migrate'))
-            usage(context.command);
-        return { action: argv[0] };
-    },
-    execute(intent, context) {
-        if (intent.action === 'gc')
-            return gcHostLedger({ env: context.env, dryRun: intent.dryRun });
-        const options = { env: context.env };
-        return intent.action === 'verify' ? verifyHostLedger(options) : migrateHostLedger(options);
-    },
-    present(result) {
-        if ('dryRun' in result) {
-            process.stdout.write(renderMaintenance(result));
-            return;
-        }
-        process.stdout.write(renderReport(result));
-        if (result.ready === false)
-            process.exitCode = 2;
-    },
-};

package/dist/host-ledger-file-adapter.d.ts

@@ -1,47 +0,0 @@
-import { type VersionObserver } from './file-changes.js';
-import type { HostLedgerPort, PresenceRecord, PresenceKey, PresenceLookup, PresenceResult, PresenceClaimResult, EvidenceRecord, EvidenceClaim, EvidenceRelease, EvidenceLookup, NativeTokenLookup, NativeTokenResult, ClaimResult, WakeAttemptClaim, WakeAttemptClaimInput, WakeAttemptLookup } from './host-ledger.js';
-export interface HostLedgerFileAdapterOptions {
-    rootPath?: string;
-    now?: () => number;
-}
-/** Existing port surface; each operation owns a short-lived SQLite connection. */
-export declare class FileHostLedgerPort implements HostLedgerPort {
-    private readonly root;
-    private readonly clock;
-    constructor(o?: HostLedgerFileAdapterOptions);
-    observeChanges(): Promise<{
-        presence: VersionObserver<string>;
-        evidence: VersionObserver<string>;
-    }>;
-    nextExpiry(session: string): Promise<number>;
-    withClaimLock<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
-    claimPresence(i: PresenceRecord, signal?: AbortSignal): Promise<PresenceClaimResult>;
-    ensurePresence(i: PresenceRecord): Promise<PresenceResult>;
-    suppressPresence(i: PresenceRecord, through: number): Promise<boolean>;
-    removePresence(i: PresenceKey): Promise<void>;
-    removePresenceIfUnchanged(i: PresenceRecord): Promise<boolean>;
-    listPresence(i?: PresenceLookup): Promise<readonly PresenceRecord[]>;
-    claimWakeAttempt(i: WakeAttemptClaimInput): Promise<WakeAttemptClaim>;
-    private updateWake;
-    listWakeAttempts(i?: WakeAttemptLookup): Promise<readonly EvidenceRecord[]>;
-    prepareNativeWake(i: EvidenceRecord & {
-        readonly claimToken: string;
-        readonly routeKind: import('./model.js').WakeRouteKind;
-        readonly nativeDelivery: import('./host-ledger.js').NativeDeliveryEvidence;
-    }): Promise<boolean>;
-    confirmWakeAdmission(i: EvidenceRecord & {
-        readonly claimToken: string;
-    }): Promise<boolean>;
-    observeNativeDelivery(i: EvidenceRecord & {
-        readonly claimToken: string;
-    }, observation: import('./host-ledger.js').NativeDeliveryObservation): Promise<boolean>;
-    claimEvidence(i: EvidenceClaim): Promise<ClaimResult>;
-    releaseEvidence(i: EvidenceRelease): Promise<void>;
-    appendEvidence(i: EvidenceRecord & {
-        readonly claimToken: string;
-    }): Promise<void>;
-    listEvidence(i?: EvidenceLookup): Promise<readonly EvidenceRecord[]>;
-    retireEvidenceIfUnchanged(expected: EvidenceRecord): Promise<boolean>;
-    lookupNativeTokens(input: NativeTokenLookup): Promise<NativeTokenResult>;
-}
-export declare function createHostLedgerPort(o?: HostLedgerFileAdapterOptions): FileHostLedgerPort;

package/dist/host-ledger-file-adapter.js

@@ -1,384 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { isDeepStrictEqual } from 'node:util';
-import { withFileLock as acquireFileLock } from './file-lock.js';
-import { nameKey } from './model.js';
-import { formatActivityId } from './square-core.js';
-import { hostLedgerRoot } from './host-ledger-root.js';
-import { observeFileMetadata, observeFileVersion } from './file-changes.js';
-import { canonicalPath, canonicalPathSync } from './canonical-path.js';
-import { LEDGER_FILENAME, LEDGER_RETENTION, withLedger, readLedgerRevisions } from './host-ledger-sqlite.js';
-const LOCK = { retryMs: 10 };
-// The claim fence deliberately spans asynchronous artifact/native work, never a ledger transaction.
-async function withFileLock(file, options, fn) {
-    if (options.signal?.aborted)
-        throw options.signal.reason ?? new Error('File lock acquisition aborted');
-    const directory = path.dirname(file);
-    await fs.mkdir(directory, { recursive: true });
-    try {
-        await fs.writeFile(path.join(directory, '.gitignore'), '*\n', { flag: 'wx' });
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-    }
-    try {
-        return await acquireFileLock(file, options, fn);
-    }
-    catch (error) {
-        if (options.signal?.aborted)
-            throw options.signal.reason ?? error;
-        throw error;
-    }
-}
-function identity(v) {
-    return JSON.stringify([v.location, nameKey(v.participant), v.session, v.channel, v.activity, v.kind]);
-}
-function durableWake(record) {
-    const row = record;
-    return row.kind === 'wake' && (['accepted', 'unknown', 'dispatching'].includes(row.outcome ?? '') || row.nativeDelivery?.harness === 'claude');
-}
-function finishWake(current, outcome, details = {}) {
-    const { expiresAt: _expiresAt, ownerPid: _ownerPid, unknownSource: _unknownSource, ...rest } = current;
-    return { ...rest, ...details, kind: 'wake', outcome, ...(outcome === 'unknown' ? { unknownSource: details.unknownSource ?? 'transport' } : {}) };
-}
-function processAlive(pid) {
-    if (pid === undefined)
-        return undefined;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === 'ESRCH' ? false : true;
-    }
-}
-const revisionReaders = new Map();
-async function revisions(root, entry, signal) {
-    for (;;) {
-        const metadata = await entry.metadata.read(signal);
-        if (entry.cached?.metadata === metadata)
-            return entry.cached.revisions;
-        if (entry.pending) {
-            await entry.pending;
-            continue;
-        }
-        entry.pending = readLedgerRevisions(root, entry.controller.signal).then((value) => {
-            // Never associate a snapshot with metadata obtained after the read.
-            entry.cached = { metadata, revisions: value };
-        }).finally(() => { entry.pending = undefined; });
-        await entry.pending;
-    }
-}
-async function observeLedger(root) {
-    let shared = revisionReaders.get(root);
-    if (!shared) {
-        shared = observeFileMetadata(path.join(root, LEDGER_FILENAME)).then((metadata) => ({ metadata, refs: 0, controller: new AbortController() }));
-        revisionReaders.set(root, shared);
-        void shared.catch(() => { if (revisionReaders.get(root) === shared)
-            revisionReaders.delete(root); });
-    }
-    const entry = await shared;
-    // A previous last subscriber may have closed while this acquisition awaited metadata.
-    if (revisionReaders.get(root) !== shared)
-        return observeLedger(root);
-    entry.refs += 2;
-    const release = () => { if (--entry.refs === 0) {
-        entry.controller.abort(new Error('Host ledger monitor closed'));
-        entry.metadata.close();
-        revisionReaders.delete(root);
-    } };
-    async function category(kind) {
-        const observer = await observeFileVersion(path.join(root, LEDGER_FILENAME), `host-ledger-${kind}`, async (_file, signal) => {
-            const pair = await revisions(root, entry, signal);
-            return pair === undefined ? 'missing' : String(pair[kind]);
-        });
-        let closed = false;
-        return { get generation() { return observer.generation; }, hinted: observer.hinted, read: observer.read, changed: observer.changed,
-            close() { if (!closed) {
-                closed = true;
-                observer.close();
-                release();
-            } } };
-    }
-    let presence;
-    try {
-        presence = await category('presence');
-        return { presence, evidence: await category('evidence') };
-    }
-    catch (error) {
-        if (presence)
-            presence.close();
-        else
-            release();
-        release();
-        throw error;
-    }
-}
-/** Existing port surface; each operation owns a short-lived SQLite connection. */
-export class FileHostLedgerPort {
-    root;
-    clock;
-    constructor(o = {}) {
-        this.root = canonicalPathSync(o.rootPath ?? hostLedgerRoot());
-        this.clock = o.now ?? Date.now;
-    }
-    observeChanges() { return observeLedger(this.root); }
-    async nextExpiry(session) {
-        const now = this.clock();
-        return withLedger(this.root, false, (tx) => {
-            const records = [...tx.presence({ session }, now, true), ...tx.evidence({ session, includeReleased: true }, now, true)];
-            let next = Infinity;
-            for (const { record } of records) {
-                const at = 'updatedAt' in record ? record.updatedAt : 'at' in record ? record.at : undefined;
-                if (typeof at === 'number') {
-                    if (at > now)
-                        next = Math.min(next, at);
-                    if (at + LEDGER_RETENTION + 1 > now && !durableWake(record))
-                        next = Math.min(next, at + LEDGER_RETENTION + 1);
-                }
-                if ('expiresAt' in record && typeof record.expiresAt === 'number' && record.expiresAt > now)
-                    next = Math.min(next, record.expiresAt);
-            }
-            return next;
-        }, Infinity);
-    }
-    withClaimLock(fn, signal) {
-        return withFileLock(path.join(this.root, 'presence-claim.lock'), { ...LOCK, signal }, fn);
-    }
-    async claimPresence(i, signal) {
-        const location = await canonicalPath(i.location);
-        const record = { ...i, location, updatedAt: i.updatedAt ?? this.clock(), v: 1 };
-        try {
-            return await this.withClaimLock(() => withLedger(this.root, true, (tx) => {
-                const existing = tx.presence({ location, participant: record.participant }, this.clock(), true)
-                    .map(({ record }) => record).sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0))[0];
-                if (existing !== undefined)
-                    return { status: existing.session === record.session ? 'owned' : 'busy', record: existing };
-                tx.publish('presence', this.clock());
-                tx.insert('presence', record);
-                return { status: 'acquired', record };
-            }, { status: 'degraded', record, error: new Error('Missing writable host ledger') }, signal), signal);
-        }
-        catch (error) {
-            return { status: 'degraded', record, error };
-        }
-    }
-    async ensurePresence(i) {
-        const record = { ...i, location: await canonicalPath(i.location), updatedAt: i.updatedAt ?? this.clock(), v: 1 };
-        try {
-            await withLedger(this.root, true, (tx) => {
-                const rows = tx.presence({ location: record.location, participant: record.participant, session: record.session, channel: record.channel }, this.clock(), true).filter((row) => identity(row.record) === identity(record));
-                const current = rows.at(-1)?.record;
-                const cancelledThrough = current?.epoch === record.epoch ? Math.max(current?.cancelledThrough ?? -1, record.cancelledThrough ?? -1) : record.cancelledThrough ?? -1;
-                tx.publish('presence', this.clock());
-                tx.remove('presence', rows);
-                tx.insert('presence', { ...record, ...(cancelledThrough < 0 ? {} : { cancelledThrough }) });
-            }, undefined);
-            return { status: 'ensured', record };
-        }
-        catch (error) {
-            return { status: 'degraded', record, error };
-        }
-    }
-    async suppressPresence(i, through) {
-        const record = { ...i, location: await canonicalPath(i.location) };
-        return withLedger(this.root, true, (tx) => {
-            const current = tx.presence({ location: record.location, participant: record.participant, session: record.session, channel: record.channel }, this.clock(), true).findLast((row) => identity(row.record) === identity(record) && row.record.epoch === record.epoch);
-            if (!current)
-                return false;
-            tx.publish('presence', this.clock());
-            tx.replace('presence', current.seq, { ...current.record, cancelledThrough: Math.max(current.record.cancelledThrough ?? -1, through) });
-            return true;
-        }, false);
-    }
-    async removePresence(i) {
-        const record = { ...i, location: await canonicalPath(i.location) };
-        await withLedger(this.root, true, (tx) => {
-            const rows = tx.presence({ location: record.location, participant: record.participant, session: record.session, channel: record.channel }, this.clock(), true).filter((row) => identity(row.record) === identity(record));
-            tx.publish('presence', this.clock());
-            tx.remove('presence', rows);
-        }, undefined);
-    }
-    async removePresenceIfUnchanged(i) {
-        const record = { ...i, location: await canonicalPath(i.location) };
-        return withLedger(this.root, true, (tx) => {
-            const current = tx.presence({ location: record.location, participant: record.participant, session: record.session, channel: record.channel }, this.clock(), true).findLast(({ record: row }) => identity(row) === identity(record) && (row.epoch ?? undefined) === (record.epoch ?? undefined) && (row.updatedAt ?? undefined) === (record.updatedAt ?? undefined));
-            if (!current)
-                return false;
-            tx.publish('presence', this.clock());
-            tx.remove('presence', [current]);
-            return true;
-        }, false);
-    }
-    async listPresence(i = {}) {
-        const location = i.location === undefined ? undefined : await canonicalPath(i.location);
-        return withLedger(this.root, false, (tx) => tx.presence({ ...i, location, participant: i.participant || undefined, session: i.session || undefined }, i.now ?? this.clock()).map(({ record }) => {
-            const { scope: _scope, ...row } = record;
-            return row;
-        }), []);
-    }
-    async claimWakeAttempt(i) {
-        const location = await canonicalPath(i.attention.squarePath), activity = formatActivityId(i.attention.actIndex), at = i.now ?? this.clock();
-        try {
-            return await withLedger(this.root, true, (tx) => {
-                const attention = tx.evidence({ location, participant: i.attention.recipient, activity, kind: 'wake', includeReleased: true }, at, true);
-                const terminal = attention.findLast(({ record }) => record.outcome === 'accepted') ?? attention.findLast(({ record }) => record.outcome === 'unknown');
-                if (terminal)
-                    return { status: 'terminal', record: terminal.record };
-                const interrupted = attention.filter(({ record }) => record.outcome === 'dispatching');
-                const busy = interrupted.find(({ record }) => (record.expiresAt ?? 0) > at && processAlive(record.ownerPid) !== false);
-                if (busy)
-                    return { status: 'busy', record: busy.record };
-                const nextNumber = (session) => attention.filter(({ record }) => record.session === session).reduce((highest, { record }) => Math.max(highest, record.attemptN ?? 0), 0) + 1;
-                tx.publish('evidence', at);
-                if (interrupted.length) {
-                    const recovered = interrupted.map(({ record }) => ({ ...finishWake(record, 'unknown', {
-                            unknownSource: 'interrupted', signature: 'worker_interrupted_during_dispatch', message: 'The notification worker ended after dispatch began; transport acceptance is unknown.',
-                        }), routeKind: record.routeKind ?? i.routeKind, attemptN: record.attemptN ?? nextNumber(record.session), v: 1 }));
-                    interrupted.forEach((row, index) => tx.replace('evidence', row.seq, recovered[index]));
-                    return { status: 'terminal', record: recovered[0] };
-                }
-                const attemptN = nextNumber(i.session), claimToken = `${process.pid}-${at}-${randomUUID()}`;
-                tx.insert('evidence', { v: 1, at, location, participant: i.attention.recipient, session: i.session, activity, kind: 'wake', outcome: 'dispatching', routeKind: i.routeKind, attemptN, claimToken, ownerPid: process.pid, expiresAt: at + i.leaseMs });
-                return { status: 'acquired', claimToken, attemptN };
-            }, { status: 'degraded', error: new Error('Missing writable host ledger') });
-        }
-        catch (error) {
-            return { status: 'degraded', error };
-        }
-    }
-    async updateWake(input, update, at = this.clock()) {
-        if (!input.claimToken)
-            return false;
-        const location = await canonicalPath(input.location);
-        return withLedger(this.root, true, (tx) => {
-            const current = tx.evidence({ location, participant: input.participant, activity: input.activity, session: input.session, kind: 'wake', claimToken: input.claimToken, includeReleased: true }, at, true).at(-1);
-            const next = current && update(current.record);
-            if (!next || !current)
-                return false;
-            if (next !== current.record) {
-                tx.publish('evidence', at);
-                tx.replace('evidence', current.seq, { ...next, v: 1 });
-            }
-            return true;
-        }, false);
-    }
-    async listWakeAttempts(i = {}) {
-        const attention = i.attention;
-        return this.listEvidence({ kind: 'wake', ...(attention === undefined ? {} : { location: await canonicalPath(attention.squarePath), participant: attention.recipient, activity: formatActivityId(attention.actIndex) }), session: i.session, now: i.now });
-    }
-    async prepareNativeWake(i) {
-        return this.updateWake(i, (current) => current.outcome === 'dispatching' ? { ...current, nativeDelivery: i.nativeDelivery, routeKind: i.routeKind, attemptN: i.attemptN } : undefined);
-    }
-    async confirmWakeAdmission(i) {
-        return this.updateWake(i, (current) => {
-            if (!current.nativeDelivery || !['dispatching', 'unknown', 'accepted'].includes(current.outcome))
-                return undefined;
-            return current.outcome === 'accepted' ? current : finishWake(current, 'accepted', { signature: 'native_queue_confirmed', message: undefined, diagnostic: undefined });
-        });
-    }
-    async observeNativeDelivery(i, observation) {
-        return this.updateWake(i, (current) => {
-            const native = current.nativeDelivery;
-            if (native?.harness !== 'claude' || native.messageId !== observation.messageId)
-                return undefined;
-            const observations = current.nativeObservations ?? [];
-            if (observations.some((prior) => prior.eventId === observation.eventId))
-                return current;
-            // Native custody is diagnostic evidence, never permission to retry or a queue receipt.
-            return { ...current, nativeObservations: [...observations, observation] };
-        });
-    }
-    async claimEvidence(i) {
-        if (i.kind === 'wake')
-            return { status: 'degraded', error: new Error('wake attempts are claimed with claimWakeAttempt') };
-        const at = i.now ?? this.clock(), { leaseMs, ...claim } = i;
-        const record = { ...claim, location: await canonicalPath(i.location), outcome: 'dispatching', at, expiresAt: at + leaseMs, v: 1 };
-        try {
-            return await withLedger(this.root, true, (tx) => {
-                const matching = tx.evidence({ ...record, includeReleased: true }, at, true);
-                const old = matching.findLast(({ record }) => record.outcome === 'dispatching');
-                if (old && typeof old.record.expiresAt === 'number' && old.record.expiresAt > at)
-                    return { status: 'busy', record: old.record };
-                const presented = matching.findLast(({ record }) => record.outcome === 'presented');
-                if (record.kind === 'presentation' && presented)
-                    return { status: 'delivered', record: presented.record };
-                const claimToken = `${process.pid}-${at}-${Math.random().toString(36).slice(2)}`;
-                tx.publish('evidence', at);
-                tx.remove('evidence', matching.filter(({ record }) => record.outcome === 'dispatching' || record.outcome === 'released'));
-                tx.insert('evidence', { ...record, claimToken });
-                return { status: 'acquired', claimToken };
-            }, { status: 'degraded', error: new Error('Missing writable host ledger') });
-        }
-        catch (error) {
-            return { status: 'degraded', error };
-        }
-    }
-    async releaseEvidence(i) {
-        if (i.kind === 'wake') {
-            const { signature, message, diagnostic, routeKind, attemptN } = i;
-            const details = Object.fromEntries(Object.entries({ signature, message, diagnostic, routeKind, attemptN }).filter(([, value]) => value !== undefined));
-            await this.updateWake(i, (current) => current.outcome === 'dispatching' ? finishWake(current, 'released', { ...details, at: i.now ?? this.clock() }) : undefined, i.now);
-            return;
-        }
-        const location = await canonicalPath(i.location), at = i.now ?? this.clock();
-        await withLedger(this.root, true, (tx) => {
-            const current = tx.evidence({ ...i, location, includeReleased: true, claimToken: undefined }, at, true).findLast(({ record }) => record.outcome === 'dispatching');
-            if (!current || current.record.claimToken !== i.claimToken)
-                return;
-            const { expiresAt: _expiry, ownerPid: _owner, ...rest } = current.record;
-            const details = Object.fromEntries(['routeKind', 'attemptN', 'signature', 'message', 'diagnostic'].filter((field) => i[field] !== undefined).map((field) => [field, i[field]]));
-            tx.publish('evidence', at);
-            tx.remove('evidence', [current]);
-            tx.insert('evidence', { ...rest, outcome: 'released', at, ...details });
-        }, undefined);
-    }
-    async appendEvidence(i) {
-        const record = { ...i, location: await canonicalPath(i.location), at: i.at ?? this.clock(), v: 1 };
-        if (typeof i.claimToken !== 'string' || !i.claimToken.length)
-            return;
-        if (i.kind === 'wake') {
-            if (!['accepted', 'failed', 'unknown'].includes(record.outcome))
-                return;
-            const outcome = record.outcome;
-            await this.updateWake(record, (current) => {
-                if (current.outcome !== 'dispatching' && !(current.outcome === 'unknown' && current.unknownSource === 'interrupted' && outcome === 'accepted'))
-                    return undefined;
-                return finishWake(current, outcome, { at: record.at, routeKind: record.routeKind, attemptN: record.attemptN, signature: record.signature, message: record.message, diagnostic: record.diagnostic });
-            }, record.at);
-            return;
-        }
-        await withLedger(this.root, true, (tx) => {
-            const matching = tx.evidence({ ...record, claimToken: undefined, includeReleased: true }, record.at, true);
-            const source = matching.findLast(({ record }) => record.outcome === 'dispatching');
-            if (!source || source.record.claimToken !== record.claimToken)
-                return;
-            tx.publish('evidence', record.at);
-            tx.remove('evidence', matching.filter((row) => row === source || row.record.attemptN === record.attemptN && row.record.outcome !== 'dispatching' && row.record.outcome !== 'released'));
-            tx.insert('evidence', { ...record, ...(source.record.nativeDelivery === undefined ? {} : { nativeDelivery: source.record.nativeDelivery }) });
-        }, undefined);
-    }
-    async listEvidence(i = {}) {
-        const location = i.location === undefined ? undefined : await canonicalPath(i.location);
-        return withLedger(this.root, false, (tx) => tx.evidence({ ...i, location, participant: i.participant || undefined, session: i.session || undefined, activity: i.activity || undefined, kind: i.kind || undefined }, i.now ?? this.clock()).map(({ record }) => record), []);
-    }
-    async retireEvidenceIfUnchanged(expected) {
-        if (expected.outcome === 'dispatching')
-            return false;
-        // Compare the persisted coordinate verbatim; maintenance canonicalizes only its artifact proof.
-        return withLedger(this.root, true, (tx) => {
-            const current = tx.evidence({ location: expected.location, participant: expected.participant, session: expected.session, activity: expected.activity, kind: expected.kind,
-                claimToken: expected.claimToken, includeExpired: true, includeReleased: true }, this.clock(), true)
-                .find(({ record }) => isDeepStrictEqual(record, expected));
-            return current !== undefined && tx.retireEvidence(current);
-        }, false);
-    }
-    lookupNativeTokens(input) {
-        if (!input.tokens.length)
-            return Promise.resolve({ deliveries: [], retired: [] });
-        return withLedger(this.root, false, tx => tx.nativeTokens(input), { deliveries: [], retired: [] });
-    }
-}
-export function createHostLedgerPort(o = {}) { return new FileHostLedgerPort(o); }

package/dist/host-ledger-migration.d.ts

@@ -1,27 +0,0 @@
-type Kind = 'presence' | 'evidence';
-export interface LedgerSourceReport {
-    records: number;
-    ignored: number;
-    rejected: number;
-    sha256: string | null;
-}
-export interface HostLedgerReport {
-    status: 'empty' | 'legacy' | 'sqlite' | 'migrated' | 'upgraded';
-    rootPath: string;
-    presence: number;
-    evidence: number;
-    presenceRevision?: number;
-    evidenceRevision?: number;
-    sources?: Record<Kind, LedgerSourceReport>;
-    ready?: boolean;
-}
-export interface HostLedgerMaintenanceOptions {
-    rootPath?: string;
-    env?: NodeJS.ProcessEnv;
-    signal?: AbortSignal;
-}
-/** Read-only readiness/integrity check. Never creates a root, lock, or database. */
-export declare function verifyHostLedger(options?: HostLedgerMaintenanceOptions): Promise<HostLedgerReport>;
-/** Offline only: locks fence compatible writers, but do not prove hosts have stopped. */
-export declare function migrateHostLedger(options?: HostLedgerMaintenanceOptions): Promise<HostLedgerReport>;
-export {};