@astrosheep/square 0.3.71 → 0.3.73

package/dist/ledger-maintenance.d.ts

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

package/dist/ledger-maintenance.js

@@ -0,0 +1,110 @@
+import { createArtifactPort } from './artifact.js';
+import { canonicalPath } from './canonical-path.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { validateName } from './model.js';
+import { hostLedgerForEnv } from './registry.js';
+/**
+ * Explicit host-ledger evidence maintenance.
+ *
+ * Old wake/presentation rows are retired only when a typed artifact snapshot proves the
+ * recipient's attention is permanently closed: the activity reached them historically, and
+ * either catch recorded a receipt or the recipient joined again past it. Everything else is
+ * retained. Artifacts are read directly, one snapshot per canonical location, outside any
+ * ledger lock; retirement is the ledger's exact-record compare-and-swap. No SQL lives here.
+ */
+/** A row is old enough to consider once its landing time is at least this far behind now. */
+const RETIREMENT_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+/** The canonical activity coordinate the row names; leading zeros and other spellings are invalid. */
+function activityIndex(activity) {
+    const index = parseActivityId(activity);
+    return index === undefined || formatActivityId(index) !== activity ? undefined : index;
+}
+/** Old, durably closed-looking wake/presentation rows with usable coordinates. */
+function isCandidate(record, now) {
+    if (record.kind !== 'wake' && record.kind !== 'presentation')
+        return false;
+    if (record.outcome === 'dispatching')
+        return false;
+    if (typeof record.at !== 'number' || !Number.isFinite(record.at) || record.at > now - RETIREMENT_AGE_MS)
+        return false;
+    if (typeof record.location !== 'string' || record.location.length === 0)
+        return false;
+    try {
+        validateName(record.participant);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/**
+ * One artifact snapshot for one location either proves each candidate closed or reports the
+ * whole location unavailable. A missing, unreadable, or non-artifact path returns undefined
+ * and its rows are retained.
+ */
+async function provenClosable(location, group) {
+    const artifact = createArtifactPort(location);
+    try {
+        return (await artifact.read((facts) => group.filter((candidate) => {
+            const participant = candidate.record.participant;
+            if (facts.directedAt(participant, candidate.index) === undefined)
+                return false;
+            if (facts.receipt(participant, candidate.index) !== undefined)
+                return true;
+            const lastJoin = facts.participant(participant)?.lastJoinIndex;
+            return lastJoin !== undefined && lastJoin > candidate.index;
+        }))).value;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await artifact.close();
+    }
+}
+/** Command/application entry: root selection uses the caller's captured environment. */
+export function gcHostLedger(options = {}) {
+    return maintainHostLedger(hostLedgerForEnv(options.env ?? process.env), options);
+}
+export async function maintainHostLedger(ledger, options = {}) {
+    const dryRun = options.dryRun === true;
+    const now = options.now ?? Date.now();
+    const records = await ledger.listEvidence({ includeReleased: true, includeExpired: true, now });
+    const groups = new Map();
+    for (const record of records) {
+        if (!isCandidate(record, now))
+            continue;
+        const index = activityIndex(record.activity);
+        if (index === undefined)
+            continue;
+        const location = await canonicalPath(record.location).catch(() => undefined);
+        if (location === undefined)
+            continue;
+        const group = groups.get(location);
+        if (group === undefined)
+            groups.set(location, [{ record, index }]);
+        else
+            group.push({ record, index });
+    }
+    let eligible = 0;
+    let retired = 0;
+    let casMisses = 0;
+    const unavailable = new Set();
+    for (const location of [...groups.keys()].sort()) {
+        const closable = await provenClosable(location, groups.get(location));
+        if (closable === undefined) {
+            unavailable.add(location);
+            continue;
+        }
+        eligible += closable.length;
+        if (dryRun)
+            continue;
+        for (const candidate of closable) {
+            if (await ledger.retireEvidenceIfUnchanged(candidate.record))
+                retired += 1;
+            else
+                casMisses += 1;
+        }
+    }
+    return { dryRun, eligible, retired, casMisses, unavailableArtifacts: [...unavailable].sort() };
+}

package/dist/packages/agent-delivery/src/claude.d.ts

@@ -1,14 +1,5 @@
-import type { ClaudeDeliveryResult, ClaudeSendTextOptions, ClaudeTarget } from './types.js';
-export interface ClaudeConnectExistingOptions {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
+import type { ClaudeConnectOptions, ClaudeDeliveryResult, ClaudeSendTextOptions, ClaudeTarget } from './types.js';
 /** Resolve an explicitly identified existing Claude native inbox; never discovers or starts one. */
-export declare function connectExisting(options: ClaudeConnectExistingOptions): Promise<ClaudeTarget>;
+export declare function connectExisting(options: ClaudeConnectOptions): Promise<ClaudeTarget>;
 /** Write once to Claude's next native boundary; local write is never native admission. */
 export declare function sendText(target: ClaudeTarget, text: string, options?: ClaudeSendTextOptions): Promise<ClaudeDeliveryResult>;

package/dist/packages/agent-delivery/src/index.d.ts

@@ -1,4 +1,6 @@
 import { DeliveryError } from './errors.js';
+import type { OpenCodeConnectOptions, ClaudeConnectOptions, PiConnectOptions, PaseoConnectOptions } from './types.js';
+export type { OpenCodeConnectOptions, ClaudeConnectOptions, PiConnectOptions, PaseoConnectOptions } from './types.js';
 export interface SendOptions {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
@@ -16,48 +18,6 @@ export interface Steerable<O = SendOptions> {
 export interface Queueable<O = SendOptions> {
     queue(text: string, options?: O): Promise<Receipt>;
 }
-export interface OpenCodeConnectOptions {
-    readonly harness: 'opencode';
-    readonly sessionId: string;
-    readonly endpoint?: {
-        readonly url: string;
-        readonly auth?: {
-            readonly type: 'basic';
-            readonly username: string;
-            readonly password: string;
-        };
-    };
-    readonly registrationFile?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export interface ClaudeConnectOptions {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export interface PiConnectOptions {
-    readonly harness: 'pi';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export interface PaseoConnectOptions {
-    readonly harness: 'paseo';
-    readonly agentId: string;
-    readonly endpoint?: string;
-    readonly password?: string;
-    readonly authHeader?: string;
-    readonly localCredential?: string;
-    readonly paseoHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
 export type OpenCodeAgent = Steerable<KeyedSendOptions> & Queueable<KeyedSendOptions> & {
     readonly harness: 'opencode';
     readonly sessionId: string;

package/dist/packages/agent-delivery/src/opencode.d.ts

@@ -1,14 +1,5 @@
-import { type Endpoint } from '@opencode/client/service';
-import type { OpenCodeDeliveryResult, OpenCodeTarget, OpenCodeSendTextOptions } from './types.js';
-export interface OpenCodeConnectExistingOptions {
-    readonly harness: 'opencode';
-    readonly sessionId: string;
-    readonly endpoint?: Endpoint;
-    readonly registrationFile?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
+import type { OpenCodeConnectOptions, OpenCodeDeliveryResult, OpenCodeTarget, OpenCodeSendTextOptions } from './types.js';
 /** Resolve an existing service and persisted session. Never starts or stops a service. */
-export declare function connectExisting(options: OpenCodeConnectExistingOptions): Promise<OpenCodeTarget>;
+export declare function connectExisting(options: OpenCodeConnectOptions): Promise<OpenCodeTarget>;
 /** Submit once through the shared native sender; HTTP metadata alone refines rejection. */
 export declare function sendText(target: OpenCodeTarget, text: string, options?: OpenCodeSendTextOptions): Promise<OpenCodeDeliveryResult>;

package/dist/packages/agent-delivery/src/paseo.d.ts

@@ -1,17 +1,6 @@
-import type { PaseoDeliveryResult, PaseoSendTextOptions, PaseoTarget } from './types.js';
-export interface PaseoConnectExistingOptions {
-    readonly harness: 'paseo';
-    readonly agentId: string;
-    readonly endpoint?: string;
-    readonly password?: string;
-    readonly authHeader?: string;
-    readonly localCredential?: string;
-    readonly paseoHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
+import type { PaseoConnectOptions, PaseoDeliveryResult, PaseoSendTextOptions, PaseoTarget } from './types.js';
 /** Connect to an existing daemon and address one existing agent. Never starts or stops anything. */
-export declare function connectPaseo(options: PaseoConnectExistingOptions): Promise<PaseoTarget>;
+export declare function connectPaseo(options: PaseoConnectOptions): Promise<PaseoTarget>;
 /**
  * Every call owns its daemon connection: one for connect to prove the endpoint
  * and credential, and one per send, closed again as soon as the daemon answers.

package/dist/packages/agent-delivery/src/pi-client.d.ts

@@ -1,10 +1,3 @@
-import type { PiDeliveryResult, PiSendTextOptions, PiTarget } from './types.js';
-export interface PiConnectExistingOptions {
-    readonly harness: 'pi';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export declare function connectPi(options: PiConnectExistingOptions): Promise<PiTarget>;
+import type { PiConnectOptions, PiDeliveryResult, PiSendTextOptions, PiTarget } from './types.js';
+export declare function connectPi(options: PiConnectOptions): Promise<PiTarget>;
 export declare function sendPiText(target: PiTarget, text: string, options?: PiSendTextOptions): Promise<PiDeliveryResult>;

package/dist/packages/agent-delivery/src/types.d.ts

@@ -46,6 +46,48 @@ export interface PaseoSendTextOptions {
     readonly signal?: AbortSignal;
 }
 export type SendTextOptions = OpenCodeSendTextOptions | ClaudeSendTextOptions | PiSendTextOptions | PaseoSendTextOptions;
+export interface OpenCodeConnectOptions {
+    readonly harness: 'opencode';
+    readonly sessionId: string;
+    readonly endpoint?: {
+        readonly url: string;
+        readonly auth?: {
+            readonly type: 'basic';
+            readonly username: string;
+            readonly password: string;
+        };
+    };
+    readonly registrationFile?: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface ClaudeConnectOptions {
+    readonly harness: 'claude';
+    readonly sessionId: string;
+    readonly endpoint: string;
+    readonly token?: string;
+    readonly claudeHome?: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface PiConnectOptions {
+    readonly harness: 'pi';
+    readonly sessionId: string;
+    readonly endpoint: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface PaseoConnectOptions {
+    readonly harness: 'paseo';
+    readonly agentId: string;
+    readonly endpoint?: string;
+    readonly password?: string;
+    readonly authHeader?: string;
+    readonly localCredential?: string;
+    readonly paseoHome?: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
 interface OpenCodeAttempt {
     readonly harness: 'opencode';
     readonly sessionId: string;

package/dist/participant-host.d.ts

@@ -12,8 +12,11 @@ export declare function processIdentity(env: NodeJS.ProcessEnv): {
     channel: PresenceChannel;
 };
 export declare function identityRouteDraft(context: HostContext, participant: string): Promise<Omit<WakeRoute, 'updatedAt'> | undefined>;
-export declare function publishIdentityRoute(context: HostContext, participant: string, epoch?: number): Promise<void>;
+/** One postcommit host observation; presence and route publication fail independently. */
+export declare function publishCommittedIdentity(context: HostContext, participant: string, epoch?: number): Promise<void>;
 export declare function retireIdentityRoute(context: HostContext, participant: string, expectedEpoch?: number): Promise<void>;
 export declare function assertLiveOwner(context: HostContext, participant: string, expectedEpoch?: number): Promise<boolean>;
-/** Presence is best effort and runs only after the artifact mutation commits. */
-export declare function ensureLocalPresence(context: HostContext, participant: string, epoch?: number): Promise<void>;
+/** Best-effort postcommit presence; a returned epoch also witnesses a readable host observation. */
+export declare function ensureLocalPresence(context: HostContext, participant: string, epoch?: number): Promise<{
+    readonly epoch?: number;
+} | undefined>;

package/dist/participant-host.js

@@ -1,5 +1,6 @@
-import { presenceEpoch, readParticipantOwner, sessionOwnsParticipant } from './registry.js';
+import { currentOwner, presenceEpoch, sessionOwnsParticipant } from './registry.js';
 import { firstHarnessSession } from './participant-identity.js';
+import { canonicalPath } from './canonical-path.js';
 import { defaultWakeRouteCapabilities, publishWakeRoute, retireWakeRouteFromArtifact, resolvePrimaryWakeRoute, ROUTE_FRESH_MS } from './routes.js';
 export function processIdentity(env) {
     const found = firstHarnessSession(env);
@@ -13,19 +14,17 @@ export async function identityRouteDraft(context, participant) {
     const capabilities = context.hostLedger === undefined ? { canUse: () => false } : await defaultWakeRouteCapabilities(context.hostLedger);
     return resolvePrimaryWakeRoute({ location: context.location, participant, sessionId: identity.session, provider }, context.env ?? process.env, capabilities);
 }
-async function currentOwnerEpoch(context, participant) {
-    const hostLedger = context.hostLedger;
-    if (hostLedger === undefined || context.location === undefined || context.location === 'memory')
-        return undefined;
-    const owner = await readParticipantOwner(context.location, participant, hostLedger);
-    return owner === undefined ? undefined : presenceEpoch(owner);
-}
-export async function publishIdentityRoute(context, participant, epoch) {
-    const route = await identityRouteDraft(context, participant);
-    if (route === undefined)
+/** One postcommit host observation; presence and route publication fail independently. */
+export async function publishCommittedIdentity(context, participant, epoch) {
+    const observed = await ensureLocalPresence(context, participant, epoch).catch(() => undefined);
+    if (observed === undefined)
         return;
-    const ownerEpoch = epoch ?? await currentOwnerEpoch(context, participant);
-    await publishWakeRoute(context.artifact, { ...route, ...(ownerEpoch === undefined ? {} : { epoch: ownerEpoch }) }, { at: context.clock(), requireCurrentSession: true }).catch(() => undefined);
+    try {
+        const route = await identityRouteDraft(context, participant);
+        if (route !== undefined)
+            await publishWakeRoute(context.artifact, { ...route, ...observed }, { at: context.clock(), requireCurrentSession: true });
+    }
+    catch { /* Optional route enrichment cannot undo the committed activity. */ }
 }
 export async function retireIdentityRoute(context, participant, expectedEpoch) {
     if (context.location === undefined || context.location === 'memory')
@@ -43,35 +42,42 @@ export async function assertLiveOwner(context, participant, expectedEpoch) {
         return true;
     return sessionOwnsParticipant(context.location, participant, identity.session, hostLedger, expectedEpoch);
 }
-/** Presence is best effort and runs only after the artifact mutation commits. */
+/** Best-effort postcommit presence; a returned epoch also witnesses a readable host observation. */
 export async function ensureLocalPresence(context, participant, epoch) {
     if (context.hostLedger === undefined || context.location === undefined || context.location === 'memory')
         return;
     const identity = processIdentity(context.env ?? process.env);
-    const ownerEpoch = epoch ?? await currentOwnerEpoch(context, participant);
-    const now = context.clock();
-    // Semantic publish: an unexpired presence row already stands when it carries the same owner epoch.
+    const now = Date.now();
+    let existing;
     try {
-        const existing = await context.hostLedger.listPresence({ location: context.location, participant, session: identity.session, now });
-        if (existing.some((row) => row.channel === identity.channel
-            && now - (row.updatedAt ?? 0) < ROUTE_FRESH_MS
-            && (ownerEpoch === undefined || presenceEpoch(row) === ownerEpoch)))
-            return;
+        existing = await context.hostLedger.listPresence({ location: await canonicalPath(context.location), participant, now });
+    }
+    catch (error) {
+        process.stderr.write(`! host presence degraded: ${error instanceof Error ? error.message : String(error)}\n`);
+        return;
+    }
+    const owner = currentOwner(existing);
+    const ownerEpoch = epoch ?? (owner === undefined ? undefined : presenceEpoch(owner));
+    const observed = ownerEpoch === undefined ? {} : { epoch: ownerEpoch };
+    // A fresh exact local binding at the observed (or explicit claim) generation already stands.
+    if (existing.some((row) => row.session === identity.session && row.channel === identity.channel
+        && now - (row.updatedAt ?? 0) < ROUTE_FRESH_MS
+        && (ownerEpoch === undefined || presenceEpoch(row) === ownerEpoch)))
+        return observed;
+    try {
+        const result = await context.hostLedger.ensurePresence({
+            location: context.location,
+            participant,
+            session: identity.session,
+            channel: identity.channel,
+            updatedAt: Date.now(),
+            ...(ownerEpoch === undefined || ownerEpoch <= 0 ? {} : { epoch: ownerEpoch }),
+        });
+        if (result.status === 'degraded')
+            throw result.error;
+    }
+    catch (error) {
+        process.stderr.write(`! host presence degraded: ${error instanceof Error ? error.message : String(error)}\n`);
     }
-    catch { /* fall through to the best-effort ensure below */ }
-    const result = await context.hostLedger.ensurePresence({
-        location: context.location,
-        participant,
-        session: identity.session,
-        channel: identity.channel,
-        // Presence rows are host-ledger wall-time evidence; the square clock belongs to artifact activities.
-        updatedAt: Date.now(),
-        ...(ownerEpoch === undefined || ownerEpoch <= 0 ? {} : { epoch: ownerEpoch }),
-    }).catch((error) => ({
-        status: 'degraded',
-        record: { location: context.location, participant, session: identity.session, channel: identity.channel },
-        error,
-    }));
-    if (result.status === 'degraded')
-        process.stderr.write(`! host presence degraded: ${result.error instanceof Error ? result.error.message : String(result.error)}\n`);
+    return observed;
 }

package/dist/ports.d.ts

@@ -1,5 +1,5 @@
 import type { Act, HardCap, InboxNotification, StoredAct, WakeRoute, WakeRouteKind, WatchLease } from './model.js';
-export type { ClaimResult, EvidenceClaim, EvidenceRelease, EvidenceGc, EvidenceLookup, EvidenceRecord, HostLedgerPort, PresenceKey, PresenceLookup, PresenceRecord, PresenceClaimResult, PresenceChannel, PresenceResult, } from './host-ledger.js';
+export type { ClaimResult, EvidenceClaim, EvidenceRelease, EvidenceLookup, EvidenceRecord, NativeTokenLookup, NativeTokenResult, HostLedgerPort, PresenceKey, PresenceLookup, PresenceRecord, PresenceClaimResult, PresenceChannel, PresenceResult, } from './host-ledger.js';
 import type { HostLedgerPort } from './host-ledger.js';
 export type ActivityIndex = number;
 export interface SquareHeader {
@@ -20,6 +20,11 @@ export interface ParticipantFact {
     readonly lastActiveAt?: number;
     readonly lastJoinIndex?: number;
 }
+export interface ParticipantCounts {
+    readonly known: number;
+    readonly joined: number;
+    readonly done: number;
+}
 export interface AttentionFact {
     readonly listener: string;
     readonly target: string;
@@ -98,6 +103,7 @@ export interface RouteFact {
 export interface SquareRead {
     header(): SquareHeader;
     participant(requestedName: string): ParticipantFact | undefined;
+    participantCounts(): ParticipantCounts;
     roster(): readonly ParticipantFact[];
     attention(listener: string): readonly AttentionFact[];
     incomingAttention(sender: string): readonly AttentionFact[];

package/dist/registry.d.ts

@@ -2,6 +2,8 @@
 import { type FileHostLedgerPort } from './host-ledger-file-adapter.js';
 import type { HostLedgerPort, PresenceChannel, PresenceRecord } from './host-ledger.js';
 export declare function presenceEpoch(record: PresenceRecord | undefined): number;
+/** The current owner: the highest epoch wins, then the most recently updated row. */
+export declare function currentOwner(rows: readonly PresenceRecord[]): PresenceRecord | undefined;
 export declare function localParticipantName(squarePath: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
 export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
 export type OwnershipClaim = {

package/dist/registry.js

@@ -8,7 +8,7 @@ export function presenceEpoch(record) {
     return typeof record?.epoch === 'number' && Number.isSafeInteger(record.epoch) && record.epoch > 0 ? record.epoch : 0;
 }
 /** The current owner: the highest epoch wins, then the most recently updated row. */
-function currentOwner(rows) {
+export function currentOwner(rows) {
     return [...rows].sort((left, right) => presenceEpoch(right) - presenceEpoch(left) || (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
 }
 export async function localParticipantName(squarePath, hostLedger, env = process.env) { const canonical = await canonicalPath(squarePath); const names = new Set((await Promise.all(localSessionIdentities(env).map(async (identity) => (await hostLedger.listPresence({ location: canonical, session: identity.sessionId })).map((row) => row.participant)))).flat()); return names.size === 1 ? [...names][0] : undefined; }

package/dist/routes.js

@@ -3,15 +3,6 @@ import { canonicalPath, canonicalPathSync } from './canonical-path.js';
 export { WAKE_ROUTE_KINDS } from './model.js';
 export const ROUTE_FRESH_MS = 24 * 60 * 60 * 1000;
 export async function defaultWakeRouteCapabilities(hostLedger) {
-    let userCapable = hostLedger !== undefined;
-    if (hostLedger !== undefined) {
-        try {
-            await hostLedger.listPresence({ now: Date.now() });
-        }
-        catch {
-            userCapable = false;
-        }
-    }
     const available = new Set();
     try {
         const { CodexQueueAdapter } = await import('./codex-queue.js');
@@ -23,7 +14,7 @@ export async function defaultWakeRouteCapabilities(hostLedger) {
         available.add(new PaseoAdapter().kind);
     }
     catch { /* optional */ }
-    return { canUse: (kind, address) => userCapable && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
+    return { canUse: (kind, address) => hostLedger !== undefined && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
 }
 export function resolvePrimaryWakeRoute(boundary, env, capabilities) {
     const paseoAgentId = env.PASEO_AGENT_ID?.trim();

package/dist/runtime.d.ts

@@ -1,6 +1,6 @@
 import { type ActivityId } from './square-core.js';
 import { type StoredAct, type WatchLease } from './model.js';
-import type { SquareRead } from './ports.js';
+import type { ParticipantCounts, ParticipantFact, SquareRead } from './ports.js';
 export declare const WATCH_HEARTBEAT_MS: number;
 export declare const SLEEP_MS: number;
 export declare const STALE_MS: number;
@@ -13,6 +13,7 @@ export declare function nowMs(): number;
 export declare function rosterNames(facts: SquareRead): string[];
 export declare function inSquareCount(facts: SquareRead): number;
 export declare function actId(actOrIndex: StoredAct | number): ActivityId;
+export declare function terminalStatusFor(current: ParticipantFact | undefined, hardCap: number | null, counts: ParticipantCounts): 'capped' | 'quorum' | undefined;
 export declare function watchTerminalStatus(facts: SquareRead, name: string): 'capped' | 'quorum' | undefined;
 /** A continuous prefix stops at the first unseen historical audience edge after join. */
 export declare function readCursor(facts: SquareRead, name: string): number;

package/dist/runtime.js

@@ -1,5 +1,5 @@
 import { formatActivityId } from './square-core.js';
-import { SquareError, sameName } from './model.js';
+import { SquareError } from './model.js';
 function parseIntegerEnv(name, fallback) {
     const raw = process.env[name];
     if (raw === undefined)
@@ -27,14 +27,20 @@ export function nowMs() {
     return value;
 }
 export function rosterNames(facts) { return facts.roster().map((participant) => participant.name); }
-export function inSquareCount(facts) { return facts.roster().filter((participant) => participant.joined).length; }
+export function inSquareCount(facts) { return facts.participantCounts().joined; }
 export function actId(actOrIndex) { return formatActivityId(typeof actOrIndex === 'number' ? actOrIndex : actOrIndex.index); }
+export function terminalStatusFor(current, hardCap, counts) {
+    if (hardCap !== null && (current?.sayCount ?? 0) >= hardCap)
+        return 'capped';
+    const peers = counts.known - Number(current !== undefined);
+    const donePeers = counts.done - Number(current?.done === true);
+    return peers > 0 && donePeers === peers ? 'quorum' : undefined;
+}
 export function watchTerminalStatus(facts, name) {
-    const cap = facts.header().hardCap;
-    if (cap !== null && (facts.participant(name)?.sayCount ?? 0) >= cap)
+    const cap = facts.header().hardCap, current = facts.participant(name);
+    if (cap !== null && (current?.sayCount ?? 0) >= cap)
         return 'capped';
-    const peers = facts.roster().filter((participant) => !sameName(participant.name, name));
-    return peers.length > 0 && peers.every((peer) => peer.done) ? 'quorum' : undefined;
+    return terminalStatusFor(current, cap, facts.participantCounts());
 }
 /** A continuous prefix stops at the first unseen historical audience edge after join. */
 export function readCursor(facts, name) {

package/dist/sqlite-transaction.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseSync } from 'node:sqlite';
+/** Yield rather than blocking the process while another connection owns SQLite. */
+export declare function retrySqliteBusy<T>(operation: () => T, signal?: AbortSignal, retryMs?: number | (() => number)): Promise<T>;
+/** Acquisition may retry; COMMIT retries retain the callback's result and transaction. */
+export declare function inSqliteTransaction<T, V>(db: DatabaseSync, write: boolean, validate: () => V, change: (validated: V) => T, signal?: AbortSignal): Promise<T>;

package/dist/sqlite-transaction.js

@@ -0,0 +1,72 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+function abort(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new Error('SQLite operation aborted');
+}
+function isBusy(error) {
+    return error instanceof Error && /database is locked|database is busy|SQLITE_BUSY/i.test(error.message);
+}
+/** Yield rather than blocking the process while another connection owns SQLite. */
+export async function retrySqliteBusy(operation, signal, retryMs = 25) {
+    for (;;) {
+        abort(signal);
+        try {
+            return operation();
+        }
+        catch (error) {
+            if (!isBusy(error))
+                throw error;
+            try {
+                await sleep(typeof retryMs === 'function' ? retryMs() : retryMs, undefined, { signal });
+            }
+            catch (error) {
+                abort(signal);
+                throw error;
+            }
+        }
+    }
+}
+/** Acquisition may retry; COMMIT retries retain the callback's result and transaction. */
+export async function inSqliteTransaction(db, write, validate, change, signal) {
+    let begun = false, backoffMs = 25;
+    // Spread writer contenders out without delaying a writer that already owns the lock.
+    const writerDelay = () => {
+        const delay = 1 + Math.floor(Math.random() * backoffMs);
+        backoffMs = Math.min(100, backoffMs * 2);
+        return delay;
+    };
+    try {
+        const validated = await retrySqliteBusy(() => {
+            db.exec(write ? 'BEGIN IMMEDIATE' : 'BEGIN');
+            begun = true;
+            try {
+                return validate();
+            }
+            catch (error) {
+                db.exec('ROLLBACK');
+                begun = false;
+                throw error;
+            }
+        }, signal, write ? writerDelay : 25);
+        abort(signal);
+        const result = change(validated);
+        if (result !== null && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function') {
+            void Promise.resolve(result).catch(() => undefined);
+            throw new TypeError('SQLite transaction callbacks must be synchronous.');
+        }
+        // A busy commit still owns the writer lock. Retry promptly once readers leave;
+        // acquisition contenders keep the longer backoff above.
+        await retrySqliteBusy(() => db.exec('COMMIT'), signal, 1);
+        begun = false;
+        return result;
+    }
+    catch (error) {
+        if (begun) {
+            try {
+                db.exec('ROLLBACK');
+            }
+            catch { /* retain original failure */ }
+        }
+        throw error;
+    }
+}