@astrosheep/square 0.3.42 → 0.3.43

package/claude-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.42",
+  "version": "0.3.43",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.42",
+  "version": "0.3.43",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/attention-presentation.d.ts

@@ -1,5 +1,5 @@
 import type { DirectedNotificationRoute } from './model.js';
-export declare const ATTENTION_BODY_MAX = 100;
+export declare const ATTENTION_BODY_MAX = 200;
 export interface AttentionPreview {
     squarePath: string;
     actIndex: number;

package/dist/attention-presentation.js

@@ -2,7 +2,7 @@ import { homedir } from 'node:os';
 import { notificationMessageId } from './delivery.js';
 import { participantIdentity } from './presentation.js';
 import { formatActivityId } from './square-core.js';
-export const ATTENTION_BODY_MAX = 100;
+export const ATTENTION_BODY_MAX = 200;
 export function previewAttentionBody(body) {
     const compact = body.replace(/\r\n/g, '\n');
     if (compact.length <= ATTENTION_BODY_MAX)

package/dist/automatic-session.js

@@ -2,23 +2,31 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { openParticipant, Square } from './square-wiring.js';
+import { Square } from './square-wiring.js';
 import { entryPresentation } from './views.js';
 import { automaticParticipant } from './participant-identity.js';
 import { SquareError } from './model.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { projectSessionBindings } from './square-projections.js';
-import { claimSessionParticipant, releaseSessionParticipant } from './registry.js';
-import { publishWakeRoute, retireWakeRouteFromArtifact, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
+import { claimSessionParticipant, readParticipantOwner, releaseSessionParticipant } from './registry.js';
+import { publishWakeRoute, retireWakeRoutesForSessionFromArtifact, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
 export { automaticParticipant } from './participant-identity.js';
 const providerEnv = {
     codex: 'CODEX_THREAD_ID',
     claude: 'CLAUDE_CODE_SESSION_ID',
     opencode: 'OPENCODE_SESSION_ID',
-    pi: 'PI_SESSION_ID',
+    pi: 'SQUARE_PI_SESSION_ID',
 };
 function operationEnv(provider, sessionId, env) {
-    return { ...env, [providerEnv[provider]]: sessionId };
+    return {
+        ...env,
+        CLAUDE_CODE_SESSION_ID: '',
+        CLAUDE_CODE_CHILD_SESSION: '',
+        CODEX_THREAD_ID: '',
+        OPENCODE_SESSION_ID: '',
+        SQUARE_PI_SESSION_ID: '',
+        [providerEnv[provider]]: sessionId,
+    };
 }
 function hostLedgerForEnv(env) {
     const root = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
@@ -82,13 +90,20 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         if (route !== undefined) {
             const publisher = await openSquare(squarePath, { hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv });
             try {
-                await publishWakeRoute(publisher.artifact, route, { at: Date.now() });
+                await publishWakeRoute(publisher.artifact, { ...route, ...(claim?.epoch === undefined || claim.epoch <= 0 ? {} : { epoch: claim.epoch }) }, { at: Date.now(), requireCurrentSession: true });
             }
             finally {
                 await closeOpenSquare(publisher);
             }
         }
-        await hostLedgerForEnv(env).ensurePresence({ location: squarePath, participant: name, session: sessionId, channel: provider === 'claude' ? 'claude-code' : provider, updatedAt: Date.now() }, 'user');
+        await hostLedgerForEnv(env).ensurePresence({
+            location: squarePath,
+            participant: name,
+            session: sessionId,
+            channel: provider === 'claude' ? 'claude-code' : provider,
+            updatedAt: Date.now(),
+            ...(claim?.epoch === undefined || claim.epoch <= 0 ? {} : { epoch: claim.epoch }),
+        }, 'user');
         await square.reconcileBinding();
         return undefined;
     }
@@ -103,6 +118,8 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
 }
 export async function automaticSessionEnd(provider, sessionId, cwd, env = process.env) {
     const squarePath = publicSquarePath(cwd);
+    if (!await squareExists(squarePath))
+        return;
     const scopedEnv = operationEnv(provider, sessionId, env);
     const hostLedger = hostLedgerForEnv(scopedEnv);
     const probe = await openSquare(squarePath, { hostLedger, env: scopedEnv });
@@ -112,32 +129,30 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
         location: probe.location,
         scopes: ['user', 'local'],
     }))[0];
+    const expectedEpoch = binding === undefined
+        ? undefined
+        : (await readParticipantOwner(squarePath, binding.participant, scopedEnv))?.epoch;
     await closeOpenSquare(probe);
-    if (binding === undefined || !await squareExists(squarePath))
-        return;
-    const reader = await openSquare(squarePath);
-    const joined = await entryPresentation(reader, binding.participant).finally(() => closeOpenSquare(reader));
-    if (!joined.joined)
-        return;
-    const opened = await openParticipant({ path: squarePath, hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv }, binding.participant);
+    const square = await Square.at({ path: squarePath, hostLedger, env: scopedEnv });
     try {
-        await opened.participant.done();
-        const reconciler = await openSquare(squarePath);
-        try {
-            await hostLedger.reconcileBinding({ artifact: reconciler.artifact });
-        }
-        finally {
-            await closeOpenSquare(reconciler);
+        if (binding !== undefined) {
+            const reader = await openSquare(squarePath);
+            const joined = await entryPresentation(reader, binding.participant).finally(() => closeOpenSquare(reader));
+            if (joined.joined) {
+                const ended = await square.endOwnedSession(binding.participant, sessionId, expectedEpoch);
+                if (ended !== null)
+                    await square.reconcileBinding();
+            }
         }
         const cleanup = await openSquare(squarePath);
         try {
-            await retireWakeRouteFromArtifact(cleanup.artifact, { location: squarePath, participant: binding.participant, sessionId });
+            await retireWakeRoutesForSessionFromArtifact(cleanup.artifact, { location: squarePath, sessionId });
         }
         finally {
             await closeOpenSquare(cleanup);
         }
     }
     finally {
-        await opened.close();
+        await square.close();
     }
 }

package/dist/boundary-presentation.js

@@ -147,5 +147,5 @@ export async function presentPendingAtBoundary(sessionId, present, lookup = sess
     const ledgerRoot = env.SQUARE_HOST_LEDGER_USER
         ?? (env.SQUARE_REGISTRY === undefined ? path.join(os.homedir(), '.square', 'host-ledger') : path.dirname(env.SQUARE_REGISTRY));
     const ownerKey = createHash('sha256').update(sessionId).digest('hex');
-    return withFileLock(path.join(ledgerRoot, `presentation-boundary-${ownerKey}.lock`), { retryMs: 10, staleMs: 300_000, signal }, () => presentPendingAtBoundaryUnlocked(sessionId, present, lookup, env, signal));
+    return withFileLock(path.join(ledgerRoot, `presentation-boundary-${ownerKey}.lock`), { retryMs: 10, signal }, () => presentPendingAtBoundaryUnlocked(sessionId, present, lookup, env, signal));
 }

package/dist/codex-boundary-state.js

@@ -63,7 +63,7 @@ export async function recordCodexBoundary(threadId, event, env = process.env) {
     if (!threadId)
         return;
     const filePath = statePath(env);
-    await withFileLock(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, async () => {
+    await withFileLock(lockPath(filePath), { retryMs: 10 }, async () => {
         const value = await readFile(filePath);
         value.nextSequence += 1;
         const current = value.threads[threadId] ?? { lastStop: 0, lastNonStop: 0 };
@@ -77,7 +77,7 @@ export async function clearCodexBoundary(threadId, env = process.env) {
     if (!threadId)
         return;
     const filePath = statePath(env);
-    await withFileLock(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, async () => {
+    await withFileLock(lockPath(filePath), { retryMs: 10 }, async () => {
         const value = await readFile(filePath);
         if (!(threadId in value.threads))
             return;

package/dist/delivery-operations.d.ts

@@ -1,11 +1,11 @@
 import { type SquareState } from './model.js';
-import type { HostLedgerPort, PresenceRecord, SquareArtifactPort, DeliverPendingInput, DeliveryResult, ObserveSquareInput, ReconcileBindingInput, SquareObservation } from './ports.js';
+import type { HostLedgerPort, PresenceRecord, PresentationEvidenceProjection, SquareArtifactPort, DeliverPendingInput, DeliveryResult, ObserveSquareInput, ReconcileBindingInput, SquareObservation } from './ports.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { type WakeAttempt } from './square-projections.js';
 export declare function observeSquare(input: ObserveSquareInput): Promise<SquareObservation>;
 export declare function reconcileBinding(input: ReconcileBindingInput): Promise<import("./host-ledger.js").ReconcileBindingResult>;
 export declare function deliverPending(input: DeliverPendingInput): Promise<DeliveryResult>;
-export declare function selectPendingWakeActivities(state: SquareState, routes: readonly PresenceRecord[], attempts: readonly WakeAttempt[], now: number, graceMs: number, limit: number, delivery?: import("./delivery.js").DeliveryModel): number[];
+export declare function selectPendingWakeActivities(state: SquareState, routes: readonly PresenceRecord[], attempts: readonly WakeAttempt[], now: number, graceMs: number, limit: number, delivery?: import("./delivery.js").DeliveryModel, presentations?: readonly PresentationEvidenceProjection[]): number[];
 export declare function sweepPending(input: {
     readonly artifact: SquareArtifactPort;
     readonly hostLedger: HostLedgerPort;

package/dist/delivery-operations.js

@@ -2,15 +2,15 @@ import { randomUUID } from 'node:crypto';
 import { formatActivityId, parseActivityId } from './square-core.js';
 import { nameKey } from './model.js';
 import { deriveDeliveryModel } from './delivery.js';
-import { isWakeRouteAttemptable } from './square-projections.js';
+import { currentSessionBindings, isWakeRouteAttemptable, presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
 import { retireWakeRouteFromArtifact } from './routes.js';
-async function attemptWakeWithin(transport, request, timeoutMs) {
+async function attemptWakeWithin(transport, request, timeoutMs, beforeSend) {
     let timer;
     const timeout = new Promise((resolve) => {
         timer = setTimeout(() => resolve({ outcome: 'unknown', diagnostic: 'transport timeout' }), timeoutMs);
     });
     try {
-        return await Promise.race([transport.attempt(request, timeoutMs), timeout]);
+        return await Promise.race([transport.attempt(request, timeoutMs, beforeSend), timeout]);
     }
     finally {
         if (timer !== undefined)
@@ -52,6 +52,14 @@ export async function deliverPending(input) {
         route: { kind: route.kind, address: route.address },
         updatedAt: route.updatedAt,
     }));
+    const liveRoutes = currentSessionBindings(routes.filter((route) => observation.bindings.some((binding) => nameKey(binding.participant) === nameKey(route.participant)
+        && binding.sessionId === route.session
+        && binding.location === route.location)));
+    let presentations = [];
+    try {
+        presentations = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: input.location, now: input.now });
+    }
+    catch { /* capability is handled by the route-level wake checks */ }
     let attempted = 0;
     let accepted = 0;
     let failed = 0;
@@ -64,21 +72,25 @@ export async function deliverPending(input) {
                 if (requested === undefined || requested !== notification.item.index)
                     continue;
             }
-            const candidates = routes.filter((route) => nameKey(route.participant) === nameKey(membership.recipient));
-            if (candidates.length === 0) {
-                notCapable += 1;
-                continue;
-            }
+            const candidates = liveRoutes.filter((route) => nameKey(route.participant) === nameKey(membership.recipient));
             let acceptedForAttention = false;
+            let failedForAttention = false;
+            let unknownForAttention = false;
+            let notCapableForAttention = false;
             try {
-                const prior = await input.hostLedger.listWakeAttempts({ attention: { squarePath: input.location, actIndex: notification.item.index, recipient: membership.recipient }, now: input.now });
+                const prior = await input.hostLedger.listWakeAttempts({ attention: { squarePath: input.location, actIndex: notification.item.index, recipient: membership.recipient }, now: Date.now() });
                 acceptedForAttention = prior.some((attempt) => attempt.outcome === 'accepted');
             }
             catch { /* capability is handled by the route-level probe */ }
             if (acceptedForAttention)
                 continue;
+            if (candidates.length === 0)
+                notCapableForAttention = true;
             for (const route of candidates) {
                 const activity = formatActivityId(notification.item.index);
+                const presented = presentations.filter((row) => row.activity === activity && row.participant.toLocaleLowerCase() === membership.recipient.toLocaleLowerCase() && row.sessionId === route.session && presentationSuppressesWake([row]));
+                if (presented.length > 0)
+                    continue;
                 const attention = { squarePath: input.location, actIndex: notification.item.index, recipient: membership.recipient };
                 const leaseMs = input.timeoutMs ?? 5000;
                 const requestRoute = { location: route.location, participant: route.participant, sessionId: route.session, channel: route.channel, kind: route.route.kind, address: { ...route.route.address }, updatedAt: route.updatedAt ?? 0 };
@@ -86,97 +98,174 @@ export async function deliverPending(input) {
                     try {
                         const probe = await input.transport.probe(requestRoute);
                         if (probe === false || (typeof probe === 'object' && probe.outcome === 'not-capable')) {
-                            notCapable += 1;
+                            notCapableForAttention = true;
                             continue;
                         }
                     }
                     catch {
-                        notCapable += 1;
+                        notCapableForAttention = true;
                         continue;
                     }
                 }
                 let leaseId = randomUUID();
                 let lease;
                 try {
-                    lease = await input.hostLedger.claimWakeDispatch({ attention, leaseId, leaseMs, session: route.session, at: input.now });
+                    lease = await input.hostLedger.claimWakeDispatch({ attention, leaseId, leaseMs, session: route.session });
                 }
                 catch {
-                    notCapable += 1;
+                    notCapableForAttention = true;
                     continue;
                 }
                 if (lease.type === 'ambiguous') {
-                    await input.hostLedger.appendEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', outcome: 'unknown', routeKind: lease.lease.routeKind ?? route.route.kind, attemptN: lease.lease.attemptN ?? 1, signature: 'worker_interrupted_during_dispatch', message: 'The notification worker ended after dispatch began; transport acceptance is unknown.', at: input.now });
-                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId: lease.lease.leaseId, session: route.session, at: input.now });
-                    continue;
+                    let recovered = await input.hostLedger.claimEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', leaseMs, claimToken: lease.lease.leaseId });
+                    if (recovered.status === 'busy' && recovered.record.claimToken !== undefined) {
+                        await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken: recovered.record.claimToken });
+                        recovered = await input.hostLedger.claimEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', leaseMs, claimToken: lease.lease.leaseId });
+                    }
+                    if (recovered.status === 'acquired') {
+                        await input.hostLedger.appendEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', outcome: 'unknown', routeKind: lease.lease.routeKind ?? route.route.kind, attemptN: lease.lease.attemptN ?? 1, signature: 'worker_interrupted_during_dispatch', message: 'The notification worker ended after dispatch began; transport acceptance is unknown.', claimToken: recovered.claimToken });
+                    }
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId: lease.lease.leaseId, session: route.session });
+                    break;
                 }
+                if (lease.type === 'busy')
+                    break;
                 if (lease.type !== 'acquired')
                     continue;
+                try {
+                    const completed = await input.hostLedger.listWakeAttempts({ attention, now: Date.now() });
+                    if (completed.some((attempt) => attempt.outcome === 'accepted')) {
+                        await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
+                        acceptedForAttention = true;
+                        break;
+                    }
+                }
+                catch { /* continue with the evidence claim */ }
                 let attempts;
                 try {
-                    attempts = await input.hostLedger.listWakeAttempts({ attention, session: route.session, now: input.now });
+                    attempts = await input.hostLedger.listWakeAttempts({ attention, now: Date.now() });
                 }
                 catch {
-                    notCapable += 1;
-                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now }).catch(() => undefined);
+                    notCapableForAttention = true;
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
                     continue;
                 }
-                if (attempts.some((attempt) => attempt.routeKind === route.route.kind && attempt.outcome === 'unknown')) {
-                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now });
-                    continue;
+                if (attempts.some((attempt) => attempt.outcome === 'unknown')) {
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
+                    break;
                 }
-                const attemptN = attempts.reduce((highest, record) => Math.max(highest, record.attemptN ?? 0), 0) + 1;
+                const sessionAttempts = attempts.filter((attempt) => attempt.session === route.session);
+                const attemptN = sessionAttempts.reduce((highest, record) => Math.max(highest, record.attemptN ?? 0), 0) + 1;
                 const request = { location: input.location, participant: membership.recipient, activity, actor: notification.item.actor, route: requestRoute };
                 let outcome;
-                const claim = await input.hostLedger.claimEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', leaseMs, now: input.now });
+                const claim = await input.hostLedger.claimEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', leaseMs, claimToken: leaseId });
                 if (claim.status !== 'acquired') {
-                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now });
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
                     if (claim.status === 'degraded')
-                        notCapable += 1;
+                        notCapableForAttention = true;
                     continue;
                 }
-                attempted += 1;
-                const dispatching = await input.hostLedger.transitionWakeDispatch({ attention, leaseId, phase: 'dispatching', leaseMs, routeKind: route.route.kind, attemptN, session: route.session, at: input.now });
+                const claimToken = claim.claimToken;
+                const dispatching = await input.hostLedger.transitionWakeDispatch({ attention, leaseId, phase: 'dispatching', leaseMs, routeKind: route.route.kind, attemptN, session: route.session });
                 if (!dispatching) {
-                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now });
+                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
                     continue;
                 }
+                let current;
                 try {
-                    outcome = await attemptWakeWithin(input.transport, request, leaseMs);
+                    current = await observeSquare({ artifact: input.artifact, hostLedger: input.hostLedger, location: input.location, now: input.now });
+                }
+                catch {
+                    current = { ...observation, pending: [], bindings: [] };
+                }
+                const stillPending = current.pending.some((entry) => nameKey(entry.recipient) === nameKey(membership.recipient)
+                    && entry.notifications.some((entryNotification) => entryNotification.item.index === notification.item.index));
+                const stillBound = current.bindings.some((binding) => nameKey(binding.participant) === nameKey(route.participant)
+                    && binding.sessionId === route.session
+                    && binding.location === route.location);
+                const stillPublished = (current.state.routes ?? []).some((published) => published.location === route.location
+                    && nameKey(published.participant) === nameKey(route.participant)
+                    && published.sessionId === route.session
+                    && published.kind === route.route.kind
+                    && JSON.stringify(published.address) === JSON.stringify(route.route.address));
+                if (!stillPending || !stillBound || !stillPublished) {
+                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
+                    continue;
+                }
+                let latestPresentations = [];
+                try {
+                    latestPresentations = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, sessionId: route.session, activity, now: input.now });
+                }
+                catch { /* capability is handled by the transport path */ }
+                if (presentationSuppressesWake(latestPresentations)) {
+                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
+                    continue;
+                }
+                let suppressedDuringSend = false;
+                const beforeSend = async () => {
+                    let finalPresentations = [];
+                    try {
+                        finalPresentations = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, sessionId: route.session, activity, now: Date.now() });
+                    }
+                    catch { /* capability is handled by the transport path */ }
+                    suppressedDuringSend = presentationSuppressesWake(finalPresentations);
+                    return !suppressedDuringSend;
+                };
+                try {
+                    outcome = await attemptWakeWithin(input.transport, request, leaseMs, beforeSend);
                 }
                 catch (error) {
                     outcome = { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };
                 }
+                if (suppressedDuringSend) {
+                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
+                    continue;
+                }
+                attempted += 1;
                 if (outcome.outcome === 'not-capable') {
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', now: input.now }).catch(() => undefined);
-                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now }).catch(() => undefined);
-                    notCapable += 1;
+                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).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.session });
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', now: input.now });
-                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now });
-                    failed += 1;
+                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken });
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
+                    failedForAttention = true;
                     continue;
                 }
-                await input.hostLedger.appendEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', outcome: outcome.outcome, routeKind: route.route.kind, attemptN: outcome.attemptN ?? attemptN, ...(outcome.outcome === 'accepted' && outcome.signature === undefined ? {} : outcome.outcome === 'accepted' ? { signature: outcome.signature } : outcome.outcome === 'failed' ? { message: outcome.message } : { diagnostic: outcome.diagnostic }), at: input.now });
-                await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now });
+                await input.hostLedger.appendEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', outcome: outcome.outcome, routeKind: route.route.kind, attemptN: outcome.attemptN ?? attemptN, ...(outcome.outcome === 'accepted' && outcome.signature === undefined ? {} : outcome.outcome === 'accepted' ? { signature: outcome.signature } : outcome.outcome === 'failed' ? { message: outcome.message } : { diagnostic: outcome.diagnostic }), claimToken });
+                await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
                 if (outcome.outcome === 'accepted') {
-                    accepted += 1;
                     acceptedForAttention = true;
                     break;
                 }
                 if (outcome.outcome === 'failed')
-                    failed += 1;
-                else
-                    unknown += 1;
+                    failedForAttention = true;
+                else {
+                    unknownForAttention = true;
+                    break;
+                }
             }
+            if (acceptedForAttention)
+                accepted += 1;
+            else if (unknownForAttention)
+                unknown += 1;
+            else if (failedForAttention)
+                failed += 1;
+            else if (notCapableForAttention)
+                notCapable += 1;
         }
     }
     return { attempted, accepted, failed, unknown, notCapable };
 }
-export function selectPendingWakeActivities(state, routes, attempts, now, graceMs, limit, delivery = deriveDeliveryModel(state)) {
+export function selectPendingWakeActivities(state, routes, attempts, now, graceMs, limit, delivery = deriveDeliveryModel(state), presentations = []) {
     const selected = new Set();
     for (const membership of delivery.joinedRecipients()) {
         for (const notification of delivery.pendingFor(membership)) {
@@ -187,6 +276,9 @@ export function selectPendingWakeActivities(state, routes, attempts, now, graceM
             const eligible = routes.some((binding) => {
                 if (binding.route === undefined || nameKey(binding.participant) !== nameKey(membership))
                     return false;
+                const presented = presentations.filter((row) => row.activity === formatActivityId(notification.item.index) && row.participant.toLocaleLowerCase() === membership.toLocaleLowerCase() && row.sessionId === binding.session && presentationSuppressesWake([row]));
+                if (presented.length > 0)
+                    return false;
                 const matching = attempts.filter((attempt) => attempt.session === binding.session && nameKey(attempt.attention.recipient) === nameKey(membership) && attempt.attention.actIndex === notification.item.index);
                 return isWakeRouteAttemptable({ kind: binding.route.kind, updatedAt: binding.updatedAt ?? 0 }, matching);
             });
@@ -201,7 +293,7 @@ export async function sweepPending(input) {
     return sweepPendingFromState({ ...input, state });
 }
 export async function sweepPendingFromState(input) {
-    const bindings = (input.state.routes ?? []).map((route) => ({ location: input.location, participant: route.participant, session: route.sessionId, channel: route.channel, route: { kind: route.kind, address: route.address }, updatedAt: route.updatedAt }));
+    const bindings = currentSessionBindings((input.state.routes ?? []).map((route) => ({ location: input.location, participant: route.participant, session: route.sessionId, channel: route.channel, route: { kind: route.kind, address: route.address }, updatedAt: route.updatedAt })));
     let records = [];
     try {
         records = await input.hostLedger.listWakeAttempts({ now: input.now });
@@ -209,6 +301,13 @@ export async function sweepPendingFromState(input) {
     catch {
         records = [];
     }
+    let presentations = [];
+    try {
+        presentations = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: input.location, now: input.now });
+    }
+    catch {
+        presentations = [];
+    }
     const attempts = records.flatMap((record) => {
         const index = parseActivityId(record.activity);
         if (index === undefined || record.routeKind === undefined || typeof record.attemptN !== 'number')
@@ -216,5 +315,5 @@ export async function sweepPendingFromState(input) {
         return [{ at: record.at ?? input.now, attention: { squarePath: record.location, actIndex: index, recipient: record.participant }, routeKind: record.routeKind, outcome: record.outcome, attemptN: record.attemptN, ...(record.session === undefined ? {} : { session: record.session }) }];
     });
     const delivery = input.deriveDelivery?.(input.state) ?? deriveDeliveryModel(input.state);
-    return selectPendingWakeActivities(input.state, bindings, attempts, input.now, input.graceMs, input.limit, delivery);
+    return selectPendingWakeActivities(input.state, bindings, attempts, input.now, input.graceMs, input.limit, delivery, presentations);
 }

package/dist/file-lock.d.ts

@@ -1,6 +1,10 @@
 export interface FileLockOptions {
     retryMs: number;
-    staleMs: number;
     signal?: AbortSignal;
+    createParent?: boolean;
+}
+export declare class FileLockError extends Error {
+    readonly code: "not_a_database";
+    constructor(lockPath: string, cause?: unknown);
 }
 export declare function withFileLock<T>(lockPath: string, options: FileLockOptions, fn: () => T | Promise<T>): Promise<T>;