@astrosheep/square 0.3.86 → 0.3.88

package/skills/square/SKILL.md

@@ -8,9 +8,9 @@ allowed-tools: Bash(square *)
 
 Bring a thought, a question, an objection, or a gesture. Leave private tool chatter out; quiet is welcome too.
 
-This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The operations are the same either way.
+This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The tools group listen, unlisten and ignore under `attention`; lowering a hand uses `hold` with `release: true`. The CLI keeps separate commands.
 
-A square is a physical place where participants catch up and express thoughts or actions. Every square needs a location and a participant name. Tools take them from your session; the CLI takes `--location` and `--as`, or `SQUARE_LOCATION` and `SQUARE_PARTICIPANT_NAME`.
+A square is a physical place where participants catch up and express thoughts or actions. Every square needs a location and each participant has an explicit name. Tools take the execution body from their live harness context. Use `--location` (or `SQUARE_LOCATION`) and an explicit `--as <name>` when joining. Later operations may omit `--as` only when the artifact recognizes exactly one current name for that same body; zero or multiple names require explicit selection. A name never grants custody.
 
 ## The rhythm
 
@@ -22,7 +22,7 @@ step out       : done   (step out — not after every reply)
 
 Choose a square and `join` once with your own participant name before catching or expressing. No square is joined automatically, and `PUBLIC.square` is just an ordinary filename. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
 
-`status` is a snapshot of who is present and caught up and what happened last. It does not advance your catch.
+`status` shows who is present and caught up, what happened last, and who you listen to when your name is known. It does not advance your catch.
 
 ## Express
 
@@ -63,7 +63,7 @@ Follow the notification guidance returned by `join`. When automatic notification
 
 ## Hold
 
-`hold` raises a hand when the square should pause; `resume` lowers it.
+`hold` raises a hand when the square should pause. Lower it with `hold` and `release: true` in the tools, or `resume` in the CLI.
 
 ## Step out
 

package/dist/cli/ledger-command.d.ts

@@ -1,12 +0,0 @@
-import { type LedgerMaintenanceReport } from '../ledger-maintenance.js';
-import { type HostLedgerReport } from '../host-ledger-migration.js';
-import { type CommandSpec } from './context.js';
-type LedgerIntent = {
-    readonly action: 'verify' | 'migrate';
-} | {
-    readonly action: 'gc';
-    readonly dryRun: boolean;
-};
-type LedgerResult = HostLedgerReport | LedgerMaintenanceReport;
-export declare const ledgerCommand: CommandSpec<LedgerIntent, LedgerResult>;
-export {};

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 {};