@astrosheep/square 0.3.85 → 0.3.87

package/dist/delivery-health.js

@@ -2,12 +2,8 @@ import { collectPending } from './delivery.js';
 import { formatActivityId } from './square-core.js';
 import { participantIdentity, truncateChars } from './presentation.js';
 import { formatDuration } from './time.js';
-import { projectWakeEvidence } from './wake-eligibility.js';
-import { decodeWakeEvidence } from './wake-evidence.js';
-import { hostLedgerForEnv } from './registry.js';
-import { openSquare } from './open-square.js';
-import { closeOpenSquare } from './open-square.js';
-import { readWakeReleaseDiagnostics } from './wake-attempts.js';
+import { InternalSquareError, SquareError } from './model.js';
+import { createArtifactPort } from './artifact.js';
 const DISPLAY_ORDER = [
     'awaiting',
     'wake-accepted',
@@ -18,46 +14,68 @@ const DISPLAY_ORDER = [
 const ACTIONABLE = new Set(['wake-unknown', 'unreachable']);
 const DETAIL_LIMIT = 20;
 const DISPLAY_FIELD_LIMIT = 160;
-/** Purely classify current pending attention from the artifact and durable ledgers. */
+/** Classify current pending attention from the artifact's seats and delivery evidence. */
 export async function classifyDeliveryHealth(squarePath, opts) {
     const now = opts.now ?? Date.now();
-    const env = opts.env ?? process.env;
-    const square = await openSquare(squarePath, { clock: () => now, env });
+    const artifact = createArtifactPort(squarePath);
     try {
-        const { scan, routes, pending } = await collectPending(square.artifact);
-        const evidenceProjection = await projectWakeEvidence({ location: squarePath, routes, pending, hostLedger: square.hostLedger, now });
+        const { pending } = await collectPending(artifact);
+        const current = (await artifact.read((facts) => pending.map((note) => {
+            const seat = facts.seat(note.recipient);
+            const evidence = seat === undefined ? [] : facts.deliveryEvidence(seat.participant, seat.generation, formatActivityId(note.index));
+            return { note, seat, evidence };
+        }))).value;
         const items = [];
-        for (const participant of scan.roster) {
-            for (const note of pending.filter((head) => head.recipient === participant.name)) {
-                const ageMs = Math.max(0, now - note.at);
-                const evidence = evidenceProjection.evidence(note.recipient, note.index);
-                const kind = evidence.presented
-                    ? 'presented-not-delivered'
-                    : evidence.terminal?.outcome === 'accepted'
-                        ? 'wake-accepted'
-                        : evidence.terminal?.outcome === 'unknown'
-                            ? 'wake-unknown'
-                            : ageMs > opts.graceMs && evidence.attemptableRoutes.length === 0
-                                ? 'unreachable'
-                                : 'awaiting';
-                const attempt = evidence.terminal ?? evidence.attempts.at(-1);
-                items.push({
-                    squarePath,
-                    recipient: note.recipient,
-                    actIndex: note.index,
-                    actor: note.actor,
-                    at: note.at,
-                    ageMs,
-                    route: note.route,
-                    kind,
-                    ...(attempt === undefined ? {} : { attempt }),
-                });
-            }
+        for (const { note, seat, evidence } of current) {
+            const ageMs = Math.max(0, now - note.at);
+            const presentation = evidence.some((row) => row.kind === 'presentation' && (row.outcome === 'presented' || row.outcome === 'clipped' || row.outcome === 'unknown'
+                || row.outcome === 'dispatching' && (row.expiresAt === undefined || row.expiresAt > now)));
+            const terminal = evidence.findLast((row) => row.kind === 'wake' && (row.outcome === 'accepted' || row.outcome === 'unknown'));
+            const attemptRow = evidence.findLast((row) => row.kind === 'wake' && (row.outcome === 'accepted' || row.outcome === 'unknown' || row.outcome === 'failed'));
+            const attempt = attemptRow === undefined || seat === undefined || attemptRow.route?.kind === undefined ? undefined : {
+                at: attemptRow.at,
+                attention: { squarePath, recipient: seat.participant, actIndex: note.index },
+                routeKind: attemptRow.route.kind,
+                outcome: attemptRow.outcome,
+                attemptN: attemptRow.attemptN,
+                session: seat.body.session,
+                ...(attemptRow.signature === undefined ? {} : { signature: attemptRow.signature }),
+                ...(attemptRow.message === undefined ? {} : { message: attemptRow.message }),
+                ...(attemptRow.diagnostic === undefined ? {} : { diagnostic: attemptRow.diagnostic }),
+                ...(attemptRow.nativeObservations === undefined ? {} : { nativeObservations: attemptRow.nativeObservations }),
+            };
+            const kind = presentation
+                ? 'presented-not-delivered'
+                : terminal?.outcome === 'accepted'
+                    ? 'wake-accepted'
+                    : terminal?.outcome === 'unknown'
+                        ? 'wake-unknown'
+                        : ageMs > opts.graceMs && seat?.wakeAddress === undefined
+                            ? 'unreachable'
+                            : 'awaiting';
+            items.push({
+                squarePath,
+                recipient: note.recipient,
+                actIndex: note.index,
+                actor: note.actor,
+                at: note.at,
+                ageMs,
+                route: note.route,
+                kind,
+                ...(attempt === undefined ? {} : { attempt }),
+            });
         }
+        // The captured pending set is the ownership boundary: a candidate that was
+        // not pending at the scan cannot become a health item during this read.
         return items;
     }
+    catch (error) {
+        if (error instanceof InternalSquareError && error.code === 'not_found')
+            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
+        throw error;
+    }
     finally {
-        await closeOpenSquare(square);
+        await artifact.close();
     }
 }
 function displayField(value) {
@@ -110,13 +128,58 @@ function formatRelease(release, now) {
     const diagnostic = release.diagnostic === undefined ? '' : ` · ${displayField(JSON.stringify(release.diagnostic))}`;
     return `  · ${formatActivityId(release.attention.actIndex)} → ${displayField(participantIdentity(release.attention.recipient))} · ${route} · ${reason} · ${age}${message}${diagnostic}`;
 }
+function deliveryAttempt(squarePath, row, session) {
+    if (row.route?.kind === undefined || row.outcome === 'released' || row.outcome === 'dispatching')
+        return undefined;
+    return {
+        at: row.at,
+        attention: { squarePath, recipient: row.participant, actIndex: Number(row.activity.slice(4)) },
+        routeKind: row.route.kind,
+        outcome: row.outcome,
+        attemptN: row.attemptN,
+        ...(session === undefined ? {} : { session }),
+        ...(row.signature === undefined ? {} : { signature: row.signature }),
+        ...(row.message === undefined ? {} : { message: row.message }),
+        ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
+        ...(row.nativeObservations === undefined ? {} : { nativeObservations: row.nativeObservations }),
+    };
+}
+function deliveryRelease(squarePath, row) {
+    return {
+        at: row.at,
+        attention: { squarePath, recipient: row.participant, actIndex: Number(row.activity.slice(4)) },
+        routeKind: row.route?.kind,
+        attemptN: row.attemptN,
+        ...(row.signature === undefined ? {} : { signature: row.signature }),
+        ...(row.message === undefined ? {} : { message: row.message }),
+        ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
+    };
+}
 export async function doctorDeliveryHealth(squarePath, graceMs, now = Date.now(), env = process.env) {
     const items = await classifyDeliveryHealth(squarePath, { graceMs, now, env });
-    const releases = await readWakeReleaseDiagnostics({ location: squarePath, now, env });
-    const rows = await hostLedgerForEnv(env).listEvidence({ location: squarePath, kind: 'wake', includeReleased: true, now });
-    const nativeAttempts = rows.flatMap((row) => {
-        const decoded = decodeWakeEvidence(row, now);
-        return decoded?.kind === 'attempt' && decoded.value.nativeObservations?.length ? [decoded.value] : [];
-    }).sort((a, b) => Math.max(...b.nativeObservations.map((row) => row.observedAt)) - Math.max(...a.nativeObservations.map((row) => row.observedAt)));
-    return renderDeliveryHealth(items, releases, now, nativeAttempts);
+    const artifact = createArtifactPort(squarePath);
+    try {
+        const { value: rows } = await artifact.read((facts) => facts.roster().flatMap((participant) => {
+            const seat = facts.seat(participant.name);
+            return seat === undefined ? [] : facts.deliveryEvidence(seat.participant, seat.generation);
+        }));
+        const releases = rows.filter((row) => row.kind === 'wake' && row.outcome === 'released')
+            .map((row) => deliveryRelease(squarePath, row))
+            .sort((left, right) => right.at - left.at);
+        const nativeAttempts = rows.flatMap((row) => {
+            if (row.kind !== 'wake' || row.nativeObservations?.length === 0)
+                return [];
+            const attempt = deliveryAttempt(squarePath, row);
+            return attempt?.nativeObservations?.length ? [attempt] : [];
+        }).sort((a, b) => Math.max(...b.nativeObservations.map((row) => row.observedAt)) - Math.max(...a.nativeObservations.map((row) => row.observedAt)));
+        return renderDeliveryHealth(items, releases, now, nativeAttempts);
+    }
+    catch (error) {
+        if (error instanceof InternalSquareError && error.code === 'not_found')
+            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
+        throw error;
+    }
+    finally {
+        await artifact.close();
+    }
 }

package/dist/delivery-operations.d.ts

@@ -1,8 +1,7 @@
-import type { HostLedgerPort, SquareArtifactPort, DeliverPendingInput, DeliveryResult } from './ports.js';
+import type { SquareArtifactPort, DeliverPendingInput, DeliveryResult } from './ports.js';
 export declare function deliverPending(input: DeliverPendingInput): Promise<DeliveryResult>;
 export declare function sweepPending(input: {
     readonly artifact: SquareArtifactPort;
-    readonly hostLedger: HostLedgerPort;
     readonly location: string;
     readonly now: number;
     readonly graceMs: number;

package/dist/delivery-operations.js

@@ -1,23 +1,41 @@
+import { randomUUID } from 'node:crypto';
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { capturePendingScan, collectPending, pendingFacts, pendingHead, pendingPages, sameJoin } from './delivery.js';
-import { projectWakeEvidence, wakeIsEligible } from './wake-eligibility.js';
+import { sameBody } from './model.js';
+import { pendingHead, pendingHeads, pendingRecipients, presentationBlocksWake } from './delivery.js';
+import { asSeatRef } from './seats.js';
 import { canonicalPath } from './canonical-path.js';
-import { retireWakeRouteFromArtifact } from './routes.js';
-import { redactCurrentDiagnostic } from './diagnostic-redaction.js';
-async function releaseWakeClaim(input, details) {
-    await input.hostLedger.releaseEvidence({
-        location: input.location,
-        participant: input.participant,
-        session: input.session,
-        activity: input.activity,
-        kind: 'wake',
-        claimToken: input.claimToken,
-        ...(input.routeKind === undefined ? {} : { routeKind: input.routeKind }),
-        ...(input.attemptN === undefined ? {} : { attemptN: input.attemptN }),
-        signature: details.signature,
-        message: redactCurrentDiagnostic(details.message),
-        ...(details.diagnostic === undefined ? {} : { diagnostic: redactCurrentDiagnostic(details.diagnostic) }),
+import { freshWatchLease } from './runtime.js';
+import { leaseOwnsNotification } from './delivery.js';
+function routeFor(location, seat, now) {
+    if (seat.wakeAddress === undefined)
+        return undefined;
+    return {
+        location, participant: seat.participant, sessionId: seat.body.session, channel: seat.body.channel,
+        kind: seat.wakeAddress.kind, address: { ...seat.wakeAddress.address }, updatedAt: now,
+    };
+}
+async function currentness(artifact, request, now) {
+    const index = parseActivityId(request.activity);
+    const { value } = await artifact.read((facts) => {
+        const currentSeat = facts.seat(request.participant);
+        const seatCurrent = currentSeat !== undefined && currentSeat.generation === request.seat.generation
+            && sameBody(currentSeat.body, request.seat.body)
+            && currentSeat.wakeAddress?.kind === request.route.kind
+            && Object.keys(currentSeat.wakeAddress.address).length === Object.keys(request.route.address).length
+            && Object.entries(currentSeat.wakeAddress.address).every(([key, val]) => request.route.address[key] === val);
+        const head = pendingHead(facts, request.participant, index);
+        const activityPending = seatCurrent && head !== undefined;
+        const cancelledThrough = facts.cancelledThrough(request.participant, request.seat.generation);
+        const cancelled = cancelledThrough !== undefined && index <= cancelledThrough;
+        const evidence = facts.deliveryEvidence(request.participant, request.seat.generation, formatActivityId(index));
+        const presented = presentationBlocksWake(evidence, now);
+        const lease = freshWatchLease(facts, request.participant, now);
+        const caught = head !== undefined && lease !== undefined && leaseOwnsNotification(lease, {
+            actor: request.actor, route: head.route, recipient: request.participant,
+        });
+        return { current: activityPending && !cancelled && !presented && !caught, activityPending, seatCurrent, cancelled, presented };
     });
+    return value;
 }
 async function attemptWakeWithin(transport, request, timeoutMs, beforeSend) {
     let timer;
@@ -32,201 +50,142 @@ async function attemptWakeWithin(transport, request, timeoutMs, beforeSend) {
             clearTimeout(timer);
     }
 }
+async function candidates(artifact, requested) {
+    const { value } = await artifact.read((facts) => {
+        const heads = requested === undefined
+            ? facts.roster().flatMap((participant) => participant.joined ? pendingHeads(facts, participant.name) : [])
+            : pendingRecipients(facts, requested);
+        return heads.flatMap((head) => {
+            const seat = facts.seat(head.recipient);
+            return seat === undefined ? [] : [{ seat, head }];
+        });
+    });
+    return value;
+}
+function releaseClaim(artifact, seat, activity, claimToken, signature, message, diagnostic) {
+    return artifact.completeDelivery({ seat, activity, claimToken, outcome: 'released', at: Date.now(), signature,
+        ...(message === undefined ? {} : { message }),
+        ...(diagnostic === undefined ? {} : { diagnostic: safeJson(diagnostic) }),
+    }).catch(() => false);
+}
+function safeJson(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
+        return value;
+    if (Array.isArray(value))
+        return value.map(safeJson);
+    if (typeof value === 'object')
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, item]) => item !== undefined).map(([key, item]) => [key, safeJson(item)]));
+    return String(value);
+}
 export async function deliverPending(input) {
     const location = await canonicalPath(input.location);
-    const requested = input.activity === undefined ? undefined : typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
+    const requested = input.activity === undefined ? undefined
+        : typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
     if (input.activity !== undefined && requested === undefined)
         return { attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 0 };
-    const owners = await input.hostLedger.listPresence({ location, now: input.now ?? Date.now() });
-    const { scan, routes, pending } = await collectPending(input.artifact, requested);
-    const eligibility = await projectWakeEvidence({ routes, pending, owners, location, hostLedger: input.hostLedger, now: input.now ?? Date.now() });
-    const observeCurrentness = async (request, now) => {
-        const index = parseActivityId(request.activity);
-        const captured = scan.roster.find((participant) => participant.name === request.participant);
-        const { value: facts } = await input.artifact.read((facts) => {
-            const head = sameJoin(facts, captured) ? pendingHead(facts, request.participant, index) : undefined;
-            return { routes: facts.routes(), pending: head === undefined ? [] : [head] };
-        });
-        const projection = await projectWakeEvidence({ ...facts, bindings: owners, location, hostLedger: input.hostLedger, now });
-        return { ...projection.currentness({ ...request, location }), observationAvailable: true };
-    };
-    let attempted = 0;
-    let accepted = 0;
-    let failed = 0;
-    let unknown = 0;
-    let notCapable = 0;
-    for (const participant of scan.roster) {
-        const recipient = participant.name;
-        for (const notification of pending.filter((head) => head.recipient === recipient)) {
-            const evidence = eligibility.evidence(recipient, notification.index);
-            if (evidence.terminal !== undefined)
-                continue;
-            const candidates = evidence.attemptableRoutes;
-            let acceptedForAttention = false;
-            let failedForAttention = false;
-            let unknownForAttention = false;
-            let notCapableForAttention = false;
-            if (candidates.length === 0 && !evidence.presented)
-                notCapableForAttention = true;
-            for (const route of candidates) {
-                const activity = formatActivityId(notification.index);
-                const attention = { squarePath: location, actIndex: notification.index, recipient };
-                const leaseMs = input.timeoutMs ?? 5000;
-                const requestRoute = route;
-                if (input.transport.probe !== undefined) {
-                    try {
-                        const probe = await input.transport.probe(requestRoute);
-                        if (probe === false || (typeof probe === 'object' && probe.outcome === 'not-capable')) {
-                            notCapableForAttention = true;
-                            continue;
-                        }
-                    }
-                    catch {
-                        notCapableForAttention = true;
-                        continue;
-                    }
-                }
-                let claim;
-                try {
-                    claim = await input.hostLedger.claimWakeAttempt({ attention, session: route.sessionId, routeKind: route.kind, leaseMs });
-                }
-                catch {
-                    notCapableForAttention = true;
-                    continue;
-                }
-                if (claim.status === 'degraded') {
-                    notCapableForAttention = true;
-                    continue;
-                }
-                // Busy and terminal outcomes are attention-wide: no other session or route may dispatch.
-                // A terminal attempt was already accepted or may already have been sent, so it reports nothing new.
-                if (claim.status === 'busy')
-                    break;
-                if (claim.status === 'terminal')
-                    break;
-                const { claimToken, attemptN } = claim;
-                const request = { location: input.location, participant: recipient, activity, actor: notification.actor, route: requestRoute };
-                const claimRelease = { hostLedger: input.hostLedger, location, participant: recipient, session: route.sessionId, activity, claimToken, routeKind: route.kind, attemptN };
-                // One teardown path for every exit after claim acquisition; each call site keeps its own error policy.
-                const abandon = async (details, options = {}) => {
-                    const release = releaseWakeClaim(claimRelease, details);
-                    if (options.bestEffortClaim === true)
-                        await release.catch(() => undefined);
-                    else
-                        await release;
-                };
-                let current;
-                try {
-                    current = await observeCurrentness(request, input.now ?? Date.now());
-                }
-                catch {
-                    await abandon({ signature: 'pre_send_revalidation_failed', message: 'Wake was not sent because current Square delivery state could not be verified.', diagnostic: { observationAvailable: false } }, { bestEffortClaim: true }).catch(() => undefined);
-                    continue;
-                }
-                if (!current.current) {
-                    await abandon({
-                        signature: current.presented ? 'presentation_already_recorded' : 'pre_send_revalidation_failed',
-                        message: current.presented ? 'Wake was suppressed because presentation evidence already exists.' : 'Wake was not sent because current attention, session binding, or route no longer matches.',
-                        diagnostic: current,
-                    }, { bestEffortClaim: true }).catch(() => undefined);
-                    continue;
-                }
-                let outcome;
-                let suppressedDuringSend = false;
-                let finalCurrentness;
-                const beforeSend = async () => {
-                    try {
-                        finalCurrentness = await observeCurrentness(request, Date.now());
-                        suppressedDuringSend = !finalCurrentness.current;
-                    }
-                    catch {
-                        suppressedDuringSend = true;
-                    }
-                    return !suppressedDuringSend;
-                };
-                try {
-                    outcome = await attemptWakeWithin(input.transport, { ...request, claimToken, attemptN }, leaseMs, beforeSend);
-                }
-                catch (error) {
-                    outcome = { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };
-                }
-                if (suppressedDuringSend) {
-                    await abandon({
-                        signature: finalCurrentness?.presented === true ? 'presentation_recorded_during_dispatch' : 'pre_send_revalidation_failed',
-                        message: finalCurrentness === undefined ? 'Wake was not sent because current Square delivery state could not be verified.' : 'Wake was cancelled because current attention, ownership, cancellation, or presentation changed before the final send check.',
-                        diagnostic: finalCurrentness ?? { observationAvailable: false },
-                    }, { bestEffortClaim: true }).catch(() => undefined);
-                    continue;
-                }
-                attempted += 1;
-                if (outcome.outcome === 'not-capable') {
-                    await abandon({
-                        signature: 'transport_not_capable',
-                        message: 'The wake transport reported that it could not deliver this route.',
-                        diagnostic: outcome.diagnostic,
-                    }, { bestEffortClaim: true }).catch(() => undefined);
-                    notCapableForAttention = true;
-                    continue;
-                }
-                if (outcome.outcome === 'failed' && outcome.unavailable) {
-                    if (outcome.routeStale === true)
-                        await retireWakeRouteFromArtifact(input.artifact, { location: route.location, participant: route.participant, sessionId: route.sessionId });
-                    await abandon({
-                        signature: outcome.signature ?? 'transport_unavailable',
-                        message: outcome.message ?? 'The wake transport was unavailable.',
-                        diagnostic: outcome.diagnostic,
-                    });
-                    failedForAttention = true;
+    const pending = await candidates(input.artifact, requested);
+    let attempted = 0, accepted = 0, failed = 0, unknown = 0, notCapable = 0;
+    for (const { seat, head } of pending) {
+        const route = routeFor(location, seat, input.now ?? Date.now());
+        if (route === undefined) {
+            notCapable += 1;
+            continue;
+        }
+        const request = {
+            location, participant: seat.participant, activity: formatActivityId(head.index), actor: head.actor,
+            seat: asSeatRef(seat), route,
+            artifact: input.artifact,
+        };
+        if (input.transport.probe !== undefined) {
+            try {
+                const probe = await input.transport.probe(route);
+                if (probe === false || typeof probe === 'object' && probe.outcome === 'not-capable') {
+                    notCapable += 1;
                     continue;
                 }
-                const safeOutcome = redactCurrentDiagnostic(outcome);
-                await input.hostLedger.appendEvidence({ location, participant: recipient, session: route.sessionId, activity, kind: 'wake', outcome: safeOutcome.outcome, routeKind: route.kind, attemptN, ...(safeOutcome.signature === undefined ? {} : { signature: safeOutcome.signature }), ...(safeOutcome.outcome !== 'accepted' && safeOutcome.message !== undefined ? { message: safeOutcome.message } : {}), ...(safeOutcome.outcome !== 'accepted' && safeOutcome.diagnostic !== undefined ? { diagnostic: safeOutcome.diagnostic } : {}), claimToken });
-                if (outcome.outcome === 'accepted') {
-                    acceptedForAttention = true;
-                    break;
-                }
-                if (outcome.outcome === 'failed')
-                    failedForAttention = true;
-                else {
-                    unknownForAttention = true;
-                    break;
-                }
             }
-            if (acceptedForAttention)
-                accepted += 1;
-            else if (unknownForAttention)
-                unknown += 1;
-            else if (failedForAttention)
-                failed += 1;
-            else if (notCapableForAttention)
+            catch {
                 notCapable += 1;
+                continue;
+            }
         }
+        const claimToken = randomUUID();
+        const leaseMs = input.timeoutMs ?? 5000;
+        const claim = await input.artifact.claimDelivery({ seat: request.seat, activity: request.activity, kind: 'wake',
+            route: seat.wakeAddress, at: input.now ?? Date.now(), leaseMs, claimToken }).catch(() => ({ status: 'stale' }));
+        if (claim.status !== 'acquired')
+            continue;
+        const withClaim = { ...request, claimToken, attemptN: claim.attemptN };
+        let final;
+        let suppressed = false;
+        const beforeSend = async () => {
+            try {
+                final = await currentness(input.artifact, withClaim, Date.now());
+                suppressed = !final.current;
+            }
+            catch {
+                suppressed = true;
+            }
+            return !suppressed;
+        };
+        let before;
+        try {
+            before = await currentness(input.artifact, withClaim, input.now ?? Date.now());
+        }
+        catch { /* unverifiable */ }
+        if (!before?.current) {
+            await releaseClaim(input.artifact, request.seat, request.activity, claimToken, 'pre_send_revalidation_failed', before === undefined ? 'Square delivery state could not be verified.' : 'The notification is no longer current.', before);
+            continue;
+        }
+        let outcome;
+        try {
+            outcome = await attemptWakeWithin(input.transport, withClaim, leaseMs, beforeSend);
+        }
+        catch (error) {
+            outcome = { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };
+        }
+        if (suppressed) {
+            await releaseClaim(input.artifact, request.seat, request.activity, claimToken, 'pre_send_revalidation_failed', 'The notification changed before the final send check.', final ?? { observationAvailable: false });
+            continue;
+        }
+        if (outcome.outcome === 'not-capable') {
+            await releaseClaim(input.artifact, request.seat, request.activity, claimToken, 'transport_not_capable', undefined, outcome.diagnostic);
+            notCapable += 1;
+            continue;
+        }
+        attempted += 1;
+        const mapped = outcome.outcome === 'accepted' ? 'accepted'
+            : outcome.outcome === 'unknown' ? 'unknown' : 'failed';
+        const completed = await input.artifact.completeDelivery({ seat: request.seat, activity: request.activity, claimToken,
+            outcome: mapped, at: Date.now(),
+            ...('signature' in outcome && outcome.signature !== undefined ? { signature: outcome.signature } : {}),
+            ...('message' in outcome && outcome.message !== undefined ? { message: outcome.message } : {}),
+            ...('diagnostic' in outcome && outcome.diagnostic !== undefined ? { diagnostic: safeJson(outcome.diagnostic) } : {}),
+        }).catch(() => false);
+        if (!completed)
+            continue;
+        if (mapped === 'accepted')
+            accepted += 1;
+        else if (mapped === 'unknown')
+            unknown += 1;
+        else
+            failed += 1;
     }
     return { attempted, accepted, failed, unknown, notCapable };
 }
 export async function sweepPending(input) {
     if (input.limit <= 0)
         return [];
-    const location = await canonicalPath(input.location);
-    const owners = await input.hostLedger.listPresence({ location, now: input.now });
-    const { value: scan } = await input.artifact.read(capturePendingScan);
+    const pending = await candidates(input.artifact);
     const selected = [];
-    const indexes = new Set();
-    for await (const page of pendingPages(input.artifact, scan)) {
-        const { value: facts } = await input.artifact.read((facts) => pendingFacts(facts, scan, page));
-        const eligibility = await projectWakeEvidence({ ...facts, bindings: owners, location, hostLedger: input.hostLedger, now: input.now });
-        for (const head of facts.pending) {
-            if (indexes.size >= input.limit && !indexes.has(head.index))
-                break;
-            if (input.now - head.at > input.graceMs && wakeIsEligible(eligibility.evidence(head.recipient, head.index))) {
-                selected.push(head);
-                indexes.add(head.index);
-            }
-        }
-        if (indexes.size >= input.limit)
+    for (const { head } of pending) {
+        if (input.now - head.at <= input.graceMs)
+            continue;
+        if (!selected.includes(head.index))
+            selected.push(head.index);
+        if (selected.length >= input.limit)
             break;
     }
-    const { value: facts } = await input.artifact.read((facts) => pendingFacts(facts, scan, selected));
-    const eligibility = await projectWakeEvidence({ ...facts, bindings: owners, location, hostLedger: input.hostLedger, now: input.now });
-    return [...new Set(facts.pending.filter((head) => wakeIsEligible(eligibility.evidence(head.recipient, head.index))).map((head) => head.index))];
+    return selected;
 }

package/dist/delivery.d.ts

@@ -1,5 +1,5 @@
-import type { DirectedNotificationRoute, StoredAct, WatchLease, WakeRouteKind } from './model.js';
-import type { DirectedHead, ParticipantFact, SquareArtifactPort, SquareRead, WakeOutcome } from './ports.js';
+import type { DirectedNotificationRoute, StoredAct, WatchLease } from './model.js';
+import type { DeliveryEvidence, DirectedHead, ParticipantFact, SquareArtifactPort, SquareRead, WakeRequest } from './ports.js';
 export type { DirectedNotificationRoute } from './model.js';
 export type SayItem = StoredAct & {
     kind: 'say';
@@ -9,30 +9,23 @@ export interface PlannedNotification {
     recipient: string;
     route: DirectedNotificationRoute;
 }
-/** gate-rejected means the supplied beforeSend returned false and nothing was sent. */
-export type WakeAdapterResult = Exclude<WakeOutcome, {
-    outcome: 'not-capable';
-}> | {
-    outcome: 'gate-rejected';
-};
-/** One attempt's stable coordinates; retries reuse its dedup key. */
-export interface WakeDispatchContext {
-    readonly location: string;
-    readonly participant: string;
-    readonly activity: string;
-    readonly attemptN?: number;
-}
-export interface WakeAdapter {
-    readonly kind: WakeRouteKind;
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number, context?: WakeDispatchContext): Promise<WakeAdapterResult>;
-}
+/** Exact stored activity projection for transports that send an awareness reminder. */
+export declare function wakePreview(facts: SquareRead, request: WakeRequest): string | undefined;
 export interface RoutedNotification {
     actor: string;
     route: DirectedNotificationRoute;
     recipient: string;
 }
+/** Presentation custody blocks a wake, independently of native wake acceptance. */
+export declare function presentationBlocksWake(evidence: readonly DeliveryEvidence[], now: number): boolean;
+/** Preselection only: an expired wake dispatch is uncertain, never safe automatic replay. */
+export declare function automaticWakeEligible(evidence: readonly DeliveryEvidence[], now: number): boolean;
 /** Notification pending is not cursor suffix or historical catch membership. */
 export declare function pendingHead(facts: SquareRead, name: string, index: number): DirectedHead | undefined;
+/** One activity's landed recipients that still owe a wake; the rest of the roster is untouched. */
+export declare function pendingRecipients(facts: SquareRead, index: number): DirectedHead[];
+/** Still-pending directed heads for one recipient, oldest first. Bodies belong to presentation. */
+export declare function pendingHeads(facts: SquareRead, name: string): DirectedHead[];
 /** Complete recipient projection, assembled inside its one transaction. */
 export declare function pendingNotifications(facts: SquareRead, name: string): PlannedNotification[];
 export interface PendingScan {
@@ -51,12 +44,10 @@ export declare function pendingPages(artifact: SquareArtifactPort, scan: Pending
 }[], void, unknown>;
 /** A pass retains only its captured joins; routes and individual receipts are fresh. */
 export declare function pendingFacts(facts: SquareRead, scan: PendingScan, heads: readonly DirectedHead[]): {
-    routes: readonly import("./ports.js").RouteFact[];
     pending: DirectedHead[];
 };
-/** Global discovery alone uses pendingAudience; exact dispatch uses its one landed audience. */
-export declare function collectPending(artifact: SquareArtifactPort, index?: number): Promise<{
-    routes: readonly import("./ports.js").RouteFact[];
+/** Global discovery alone sweeps pendingAudience; exact dispatch uses pendingRecipients. */
+export declare function collectPending(artifact: SquareArtifactPort): Promise<{
     pending: DirectedHead[];
     scan: PendingScan;
 }>;