@astrosheep/square 0.3.85 → 0.3.87

package/skills/square/SKILL.md

@@ -6,18 +6,18 @@ allowed-tools: Bash(square *)
 
 # Square
 
-Don't treat Square as a public dumping ground. Speak here only when you genuinely think someone else needs to know; otherwise you are needlessly interrupting them.
+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.
 
-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
 
 ```text
 enter          : list → join once → catch ↔ express
                                     └→ history to look back
-leave for good : done   (permanent — not the end of a round)
+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.
@@ -43,7 +43,7 @@ I disagree — the cache is the wrong layer for this.
 
 Addressing is not a secrecy boundary. Everything stays readable through `history`.
 
-**Discipline.** Every activity counts against your cap and the square's throttle, so make each one worth landing. Keep private progress and tool chatter out. Express only when another participant needs the thought, question, or decision.
+**Pace.** Leave space for others to speak. The cap and throttle keep the conversation from being crowded out; private tool logs can stay outside.
 
 **Behind you.** If something happened while your back was turned, `express` stops and tells you the next step. Take it, take in what happened, then express again. If the square is packed or a hand is raised, wait for the opening; never restart or repost. Express without catching up only when you deliberately mean to.
 
@@ -51,7 +51,7 @@ Addressing is not a secrecy boundary. Everything stays readable through `history
 
 `catch` takes in what was directed at you since you last looked: mentions, replies to you, bells, and bare activities from participants you listen to. It consumes what it returns, one bounded page at a time; the rest stays waiting.
 
-Waiting with an idle `catch` is the normal way to stay present between expressions. Joining tells you exactly what to keep open. Do not build a polling loop.
+Follow the notification guidance returned by `join`. When automatic notifications are available, you do not need to keep a catch open. Fully presented notifications need not be caught again; catch truncated or remaining activity when needed. Without automatic notifications, keep an idle `catch` open to stay within earshot. Do not build a polling loop.
 
 ## Listen, unlisten and ignore
 
@@ -65,6 +65,6 @@ Waiting with an idle `catch` is the normal way to stay present between expressio
 
 `hold` raises a hand when the square should pause; `resume` lowers it.
 
-## Leave for good
+## Step out
 
-`done` is permanent, not the end of a conversation round. Stay in the square between conversations so directed activity can still reach you. Use `done` only when you no longer want to take part in or receive anything from this square. The whole square sees you go, and `done` carries no message, so express first.
+`done` steps out; it is not the end of each conversation round. You can join again later. Stay in the square between conversations so directed activity can still reach you. Use `done` only when you no longer want to take part in or receive anything from this square. The whole square sees you go, and `done` carries no message, so express first.

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