@astrosheep/square 0.3.28 → 0.3.30

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

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

package/claude-plugin/skills/square/SKILL.md

@@ -74,11 +74,11 @@ EOF
 ```bash
 square --location <square> --as <name> catch --now       # take in what is pending
 square --location <square> --as <name> catch --idle 30m  # wait until something relevant lands, or 30m of quiet
-square --location <square> --as <name> catch --mention   # filter to mentions
-square --location <square> --as <name> catch --from <names>
+square --location <square> --as <name> catch --now --mention       # take in pending mentions
+square --location <square> --as <name> catch --now --from <names>  # take in pending activity from named participants
 ```
 
-Waiting with `catch --idle` is the normal way to stay present between expressions — `join` prints the exact command to keep open. Do not build a polling loop.
+Every catch needs exactly one mode: `--now` or `--idle <duration>`. `--mention` and `--from` filter either mode; they do not replace it. Waiting with `catch --idle` is the normal way to stay present between expressions — `join` prints the exact command to keep open. Do not build a polling loop.
 
 ## Listen
 

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

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

package/dist/automatic-session.js

@@ -1,4 +1,4 @@
-import fs from 'node:fs';
+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';
@@ -16,9 +16,18 @@ const providerEnv = {
 export function publicSquarePath(cwd) {
     return path.join(cwd, '.square', 'PUBLIC.square');
 }
+async function squareExists(squarePath) {
+    try {
+        await fs.access(squarePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function automaticSessionStart(provider, sessionId, cwd, env = process.env) {
     const squarePath = publicSquarePath(cwd);
-    if (!fs.existsSync(squarePath))
+    if (!await squareExists(squarePath))
         return undefined;
     let reader;
     try {
@@ -29,7 +38,8 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         return undefined;
     }
     const name = automaticParticipant(provider, sessionId, env);
-    const alreadyBound = lookupSessionBindings(sessionId).some((binding) => canonicalSquarePath(binding.squarePath) === canonicalSquarePath(squarePath) && binding.name === name);
+    const canonicalPath = await canonicalSquarePath(squarePath);
+    const alreadyBound = (await lookupSessionBindings(sessionId)).some((binding) => binding.squarePath === canonicalPath && binding.name === name);
     await closeOpenSquare(reader);
     const square = await Square.at({ path: squarePath });
     try {
@@ -37,7 +47,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         if (implicit.state === 'done' || (implicit.state === 'active' && alreadyBound))
             return undefined;
         const channel = provider === 'claude' ? 'claude-code' : provider;
-        recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
+        await recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
         return undefined;
     }
     finally {
@@ -47,8 +57,9 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
 export async function automaticSessionEnd(provider, sessionId, cwd, env = process.env) {
     const squarePath = publicSquarePath(cwd);
     const channel = provider === 'claude' ? 'claude-code' : provider;
-    const binding = lookupSessionBindings(sessionId).find((item) => canonicalSquarePath(item.squarePath) === canonicalSquarePath(squarePath) && item.channel === channel);
-    if (binding === undefined || !fs.existsSync(squarePath))
+    const canonicalPath = await canonicalSquarePath(squarePath);
+    const binding = (await lookupSessionBindings(sessionId)).find((item) => item.squarePath === canonicalPath && item.channel === channel);
+    if (binding === undefined || !await squareExists(squarePath))
         return;
     const reader = await openSquare(squarePath);
     const joined = await entryPresentation(reader, binding.name).finally(() => closeOpenSquare(reader));
@@ -62,5 +73,5 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
     finally {
         await square.close();
     }
-    recordSessionDone(sessionId, binding.name, squarePath, channel, env);
+    await recordSessionDone(sessionId, binding.name, squarePath, channel, env);
 }

package/dist/boundary-presentation.d.ts

@@ -2,4 +2,4 @@ import type { InboxMembership } from './model.js';
 /** A fresh blocking catch owns only the notifications admitted by its filter. */
 export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
 export declare function renderPendingAtBoundary(inbox: InboxMembership[]): string;
-export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T | Promise<T>, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<T | undefined>;
+export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T | Promise<T>, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;

package/dist/boundary-presentation.js

@@ -76,13 +76,13 @@ function renderBoundary(inbox) {
         complete,
     };
 }
-export async function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env) {
+export async function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env, signal) {
     const inbox = await lookup(sessionId);
     let delivered;
     const result = await presentOnce(sessionId, () => pendingAtBoundary(inbox), (inbox) => {
         delivered = renderBoundary(inbox);
         return present(delivered.context);
-    }, env);
+    }, env, Date.now(), signal);
     if (result !== undefined && delivered !== undefined) {
         for (const entry of delivered.complete) {
             await markBoundarySeen(entry.membership.squarePath, entry.membership.name, entry.membership.ownerId, entry.actIndexes);

package/dist/cli/context.d.ts

@@ -29,7 +29,7 @@ export interface ParsedGlobalArgs {
     name?: string;
     args: string[];
 }
-export declare function parseGlobalArgs(rawArgs: string[]): ParsedGlobalArgs;
+export declare function parseGlobalArgs(rawArgs: string[]): Promise<ParsedGlobalArgs>;
 export declare function locationIsRequired(command: string): boolean;
 export declare function defaultContext(command: string, squarePath?: string, name?: string): CommandContext;
 export declare function requireSquarePath(context: CommandContext): string;

package/dist/cli/context.js

@@ -116,7 +116,7 @@ function configuredName() {
     validateName(value);
     return value;
 }
-export function parseGlobalArgs(rawArgs) {
+export async function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
     let requestedPath;
     let name;
@@ -144,7 +144,7 @@ export function parseGlobalArgs(rawArgs) {
     }
     const squarePath = requestedPath ?? configured;
     if (name === undefined && squarePath !== undefined && command !== undefined && locationIsRequired(command)) {
-        name = localParticipantName(squarePath);
+        name = await localParticipantName(squarePath);
     }
     return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, args };
 }

package/dist/cli/program.js

@@ -17,7 +17,7 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             await executeRegisteredCommand('help', requestedHelp.command === undefined ? [] : [requestedHelp.command], defaultContext('help'));
             return;
         }
-        const parsed = parseGlobalArgs(rawArgs);
+        const parsed = await parseGlobalArgs(rawArgs);
         if (parsed.args.length === 0 || parsed.args[0] === '--help' || parsed.args[0] === '-h') {
             await executeRegisteredCommand('help', [], defaultContext('help', parsed.squarePath, parsed.name));
             return;

package/dist/cli/square-commands.js

@@ -90,7 +90,7 @@ export const joinCommand = {
             const joinedName = participant.name;
             const isRejoin = before.joined;
             const reconnect = isRejoin
-                && localParticipantOwner(squarePath, joinedName) !== undefined;
+                && await localParticipantOwner(squarePath, joinedName) !== undefined;
             if (isRejoin && !intent.kick && !reconnect) {
                 fail([
                     `✕ ${participantIdentity(joinedName)} shoos you out of the square`,
@@ -102,7 +102,7 @@ export const joinCommand = {
             const afterSquare = await openSquare(squarePath, { clock: nowMs });
             const after = await entryPresentation(afterSquare, joinedName, intent.lastN);
             await closeOpenSquare(afterSquare);
-            recordLocalJoin(joinedName, squarePath);
+            await recordLocalJoin(joinedName, squarePath);
             await sweepPendingNotifications(squarePath);
             const activities = after.recentActivities.map((event) => renderAmbientEvent(event, joinedName, {
                 now: nowMs(),
@@ -280,7 +280,7 @@ export const doneCommand = {
         const result = await participant.done(body);
         await square.close();
         const name = result.activity.actor;
-        recordLocalDone(name, squarePath);
+        await recordLocalDone(name, squarePath);
         const presentation = await openSquare(squarePath, { clock: nowMs });
         const participantCount = (await entryPresentation(presentation, name).finally(() => closeOpenSquare(presentation))).participantCount;
         return withPathOutput(squarePath, `○ ${participantIdentity(name)} steps out of the square — done · just now`, { participantCount });

package/dist/codex-boundary-state.d.ts

@@ -2,7 +2,7 @@ export interface CodexBoundary {
     lastStop: number;
     lastNonStop: number;
 }
-export declare function readCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv): CodexBoundary | undefined;
-export declare function codexQueueEligible(threadId: string, env?: NodeJS.ProcessEnv): boolean;
-export declare function recordCodexBoundary(threadId: string, event: 'Stop' | 'non-stop', env?: NodeJS.ProcessEnv): void;
-export declare function clearCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv): void;
+export declare function readCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv): Promise<CodexBoundary | undefined>;
+export declare function codexQueueEligible(threadId: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
+export declare function recordCodexBoundary(threadId: string, event: 'Stop' | 'non-stop', env?: NodeJS.ProcessEnv): Promise<void>;
+export declare function clearCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/codex-boundary-state.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { withFileLockSync } from './file-lock.js';
+import { withFileLock } from './file-lock.js';
 function statePath(env = process.env) {
     return env.SQUARE_CODEX_BOUNDARIES || path.join(os.homedir(), '.square', 'codex-boundaries.json');
 }
@@ -11,10 +11,10 @@ function lockPath(filePath) {
 function emptyFile() {
     return { v: 1, nextSequence: 0, threads: {} };
 }
-function readFile(filePath) {
+async function readFile(filePath) {
     let raw;
     try {
-        raw = fs.readFileSync(filePath, 'utf8');
+        raw = await fs.promises.readFile(filePath, 'utf8');
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -43,45 +43,45 @@ function readFile(filePath) {
         return emptyFile();
     }
 }
-function writeFile(filePath, value) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+async function writeFile(filePath, value) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
     const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
-    fs.renameSync(temporary, filePath);
+    await fs.promises.writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    await fs.promises.rename(temporary, filePath);
 }
-export function readCodexBoundary(threadId, env = process.env) {
+export async function readCodexBoundary(threadId, env = process.env) {
     if (!threadId)
         return undefined;
     const filePath = statePath(env);
-    return readFile(filePath).threads[threadId];
+    return (await readFile(filePath)).threads[threadId];
 }
-export function codexQueueEligible(threadId, env = process.env) {
-    const boundary = readCodexBoundary(threadId, env);
+export async function codexQueueEligible(threadId, env = process.env) {
+    const boundary = await readCodexBoundary(threadId, env);
     return boundary !== undefined && boundary.lastStop > boundary.lastNonStop;
 }
-export function recordCodexBoundary(threadId, event, env = process.env) {
+export async function recordCodexBoundary(threadId, event, env = process.env) {
     if (!threadId)
         return;
     const filePath = statePath(env);
-    withFileLockSync(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, () => {
-        const value = readFile(filePath);
+    await withFileLock(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, async () => {
+        const value = await readFile(filePath);
         value.nextSequence += 1;
         const current = value.threads[threadId] ?? { lastStop: 0, lastNonStop: 0 };
         value.threads[threadId] = event === 'Stop'
             ? { ...current, lastStop: value.nextSequence }
             : { ...current, lastNonStop: value.nextSequence };
-        writeFile(filePath, value);
+        await writeFile(filePath, value);
     });
 }
-export function clearCodexBoundary(threadId, env = process.env) {
+export async function clearCodexBoundary(threadId, env = process.env) {
     if (!threadId)
         return;
     const filePath = statePath(env);
-    withFileLockSync(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, () => {
-        const value = readFile(filePath);
+    await withFileLock(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, async () => {
+        const value = await readFile(filePath);
         if (!(threadId in value.threads))
             return;
         delete value.threads[threadId];
-        writeFile(filePath, value);
+        await writeFile(filePath, value);
     });
 }

package/dist/codex-hook.js

@@ -14,7 +14,7 @@ export async function codexHookResponse(input, lookup = sessionInbox, env = proc
     const hookEventName = CODEX_HOOK_EVENTS[input.hook_event_name];
     if (hookEventName === undefined)
         return undefined;
-    recordCodexBoundary(input.session_id, hookEventName === 'Stop' ? 'Stop' : 'non-stop', env);
+    await recordCodexBoundary(input.session_id, hookEventName === 'Stop' ? 'Stop' : 'non-stop', env);
     return presentPendingAtBoundary(input.session_id, (context) => hookEventName === 'Stop'
         ? { systemMessage: context }
         : { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }, lookup, env);
@@ -46,7 +46,7 @@ export async function runCodexHookAsync(inputText, env = process.env) {
     if (typeof value.session_id !== 'string')
         return runCodexHook(inputText, env);
     if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
-        recordCodexBoundary(value.session_id, 'non-stop', env);
+        await recordCodexBoundary(value.session_id, 'non-stop', env);
         const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
         try {
             const context = await automaticSessionStart('codex', value.session_id, cwd, env);
@@ -57,7 +57,7 @@ export async function runCodexHookAsync(inputText, env = process.env) {
         }
     }
     if (value.hook_event_name === 'SessionEnd') {
-        clearCodexBoundary(value.session_id, env);
+        await clearCodexBoundary(value.session_id, env);
         const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
         try {
             await automaticSessionEnd('codex', value.session_id, cwd, env);

package/dist/codex-queue.js

@@ -39,7 +39,7 @@ export class CodexQueueAdapter {
             return { outcome: 'unavailable', signature: 'invalid_address', message: 'Codex route has no thread id.' };
         }
         const env = this.opts.env ?? process.env;
-        if (!codexQueueEligible(threadId, env)) {
+        if (!await codexQueueEligible(threadId, env)) {
             return {
                 outcome: 'unavailable',
                 signature: 'boundary_not_stopped',
@@ -49,7 +49,7 @@ export class CodexQueueAdapter {
         }
         if (!(await beforeSend()))
             return { outcome: 'cancelled' };
-        if (!codexQueueEligible(threadId, env)) {
+        if (!await codexQueueEligible(threadId, env)) {
             return {
                 outcome: 'unavailable',
                 signature: 'boundary_not_stopped',

package/dist/file-lock.d.ts

@@ -1,6 +1,6 @@
 export interface FileLockOptions {
     retryMs: number;
     staleMs: number;
+    signal?: AbortSignal;
 }
-export declare function withFileLockSync<T>(lockPath: string, options: FileLockOptions, fn: () => T): T;
 export declare function withFileLock<T>(lockPath: string, options: FileLockOptions, fn: () => T | Promise<T>): Promise<T>;

package/dist/file-lock.js

@@ -1,13 +1,11 @@
 import { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
+import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
-const lockWait = new Int32Array(new SharedArrayBuffer(4));
-const heldSyncLocks = new Set();
-function ownerState(lockPath) {
+async function ownerState(lockPath) {
     let pid;
     try {
-        pid = Number.parseInt(fs.readFileSync(lockPath, 'utf8').split('\n')[0], 10);
+        pid = Number.parseInt((await fs.readFile(lockPath, 'utf8')).split('\n')[0], 10);
     }
     catch {
         return 'unknown';
@@ -22,10 +20,10 @@ function ownerState(lockPath) {
         return error.code === 'ESRCH' ? 'dead' : 'alive';
     }
 }
-function createLock(lockPath) {
+async function createLock(lockPath) {
     let fd;
     try {
-        fd = fs.openSync(lockPath, 'wx', 0o600);
+        fd = await fs.open(lockPath, 'wx', 0o600);
     }
     catch (error) {
         if (error.code === 'EEXIST')
@@ -34,79 +32,53 @@ function createLock(lockPath) {
     }
     const token = `${process.pid}\n${Date.now()}\n${randomUUID()}\n`;
     try {
-        fs.writeFileSync(fd, token, 'utf8');
+        await fd.writeFile(token, 'utf8');
         return token;
     }
     catch (error) {
-        try {
-            fs.unlinkSync(lockPath);
-        }
-        catch { }
+        await fs.unlink(lockPath).catch(() => undefined);
         throw error;
     }
     finally {
-        fs.closeSync(fd);
+        await fd.close();
     }
 }
-function reclaimLock(lockPath, staleMs) {
+async function reclaimLock(lockPath, staleMs) {
     try {
-        const stale = Date.now() - fs.statSync(lockPath).mtimeMs > staleMs;
-        if (ownerState(lockPath) !== 'dead' && !stale)
+        const stale = Date.now() - (await fs.stat(lockPath)).mtimeMs > staleMs;
+        if (await ownerState(lockPath) !== 'dead' && !stale)
             return false;
-        fs.unlinkSync(lockPath);
+        await fs.unlink(lockPath);
         return true;
     }
     catch (error) {
         return error.code === 'ENOENT';
     }
 }
-function releaseLock(lockPath, token) {
+async function releaseLock(lockPath, token) {
     try {
-        if (fs.readFileSync(lockPath, 'utf8') === token)
-            fs.unlinkSync(lockPath);
+        if (await fs.readFile(lockPath, 'utf8') === token)
+            await fs.unlink(lockPath);
     }
     catch { }
 }
-function prepare(lockPath) {
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-}
-export function withFileLockSync(lockPath, options, fn) {
-    if (heldSyncLocks.has(lockPath))
-        throw new Error(`Reentrant file lock: ${lockPath}`);
-    prepare(lockPath);
-    let token;
-    while (token === undefined) {
-        token = createLock(lockPath);
-        if (token !== undefined)
-            break;
-        if (reclaimLock(lockPath, options.staleMs))
-            continue;
-        Atomics.wait(lockWait, 0, 0, options.retryMs);
-    }
-    heldSyncLocks.add(lockPath);
-    try {
-        return fn();
-    }
-    finally {
-        heldSyncLocks.delete(lockPath);
-        releaseLock(lockPath, token);
-    }
-}
 export async function withFileLock(lockPath, options, fn) {
-    prepare(lockPath);
+    await fs.mkdir(path.dirname(lockPath), { recursive: true });
     let token;
     while (token === undefined) {
-        token = createLock(lockPath);
+        if (options.signal?.aborted)
+            throw options.signal.reason ?? new Error('File lock acquisition aborted');
+        token = await createLock(lockPath);
         if (token !== undefined)
             break;
-        if (reclaimLock(lockPath, options.staleMs))
+        if (await reclaimLock(lockPath, options.staleMs))
             continue;
-        await sleep(options.retryMs);
+        await sleep(options.retryMs, undefined, { signal: options.signal });
     }
     try {
         return await fn();
     }
     finally {
-        releaseLock(lockPath, token);
+        await releaseLock(lockPath, token);
     }
 }

package/dist/inbox.js

@@ -18,7 +18,7 @@ function withoutExcluded(inbox, excludeKeys) {
 }
 export async function sessionInbox(sessionId) {
     const inbox = [];
-    for (const binding of lookupSessionBindings(sessionId)) {
+    for (const binding of await lookupSessionBindings(sessionId)) {
         let square;
         try {
             square = await openSquare(binding.squarePath);
@@ -53,7 +53,7 @@ export async function waitForSessionPending(sessionId, timeoutMs, options = {})
     }
     if (timeoutMs <= 0 || options.signal?.aborted)
         return [];
-    const bindings = lookupSessionBindings(sessionId);
+    const bindings = await lookupSessionBindings(sessionId);
     const paths = [...new Set(bindings.map((binding) => binding.squarePath))];
     let aborted = false;
     let projectAfterReady = !options.skipImmediate;

package/dist/notifications.d.ts

@@ -28,6 +28,6 @@ export interface SweepPendingNotificationsOptions extends WorkerLaunchOptions {
     limit?: number;
 }
 /** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: SquareState) => DeliveryModel): number[];
+export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: SquareState) => DeliveryModel): Promise<number[]>;
 /** Reconsider old pending attention at a bounded action boundary using the existing worker. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;

package/dist/notifications.js

@@ -53,7 +53,7 @@ function renderWakePayload(request, body, kind) {
     ].join('\n');
 }
 async function waitForCatch(route, request, body) {
-    const binding = lookupParticipant(request.squarePath, request.recipient)
+    const binding = (await lookupParticipant(request.squarePath, request.recipient))
         .find((item) => item.ownerId === route.ownerId);
     const activeCatch = binding && (await sessionInbox(binding.sessionId))
         .find((item) => item.name === request.recipient)?.catchLease;
@@ -68,7 +68,7 @@ async function waitForCatch(route, request, body) {
     while (Date.now() < deadline) {
         if (await hasDeliveredNotification(request.squarePath, request.recipient, request.actIndex))
             return true;
-        const currentBinding = lookupParticipant(request.squarePath, request.recipient)
+        const currentBinding = (await lookupParticipant(request.squarePath, request.recipient))
             .find((item) => item.ownerId === route.ownerId);
         const lease = currentBinding && (await sessionInbox(currentBinding.sessionId))
             .find((item) => item.name === request.recipient)?.catchLease;
@@ -101,7 +101,7 @@ export async function hasAttentionNotification(squarePath, name, ref, env = proc
     try {
         const recipient = (await resolveParticipant(square, name)).name;
         const index = notificationIndex(ref);
-        return await notificationDelivered(square, recipient, index) || hasPresentedAttention(squarePath, recipient, index, env);
+        return await notificationDelivered(square, recipient, index) || await hasPresentedAttention(squarePath, recipient, index, env);
     }
     finally {
         await closeOpenSquare(square);
@@ -162,7 +162,7 @@ async function processNotification(squarePath, notification, opts) {
         return;
     }
     if (claim.type === 'ambiguous') {
-        const recovered = recordRecoveredUnknown(attention, claim.lease, env);
+        const recovered = await recordRecoveredUnknown(attention, claim.lease, env);
         if (recovered !== undefined) {
             await releaseNotifyLease(square, notification.recipient, notification.item.index, claim.lease.leaseId);
         }
@@ -185,7 +185,7 @@ async function processNotification(squarePath, notification, opts) {
             route: notification.route,
         };
         await port.dispatch(evidence.attemptableRoutes, (route) => renderWakePayload(request, notification.item.body, route.kind), {
-            nextAttemptN: () => nextWakeAttemptNumber(attention, { env, now: now() }),
+            nextAttemptN: async () => nextWakeAttemptNumber(attention, { env, now: now() }),
             beforeSend: async (route, attemptN) => {
                 if (await waitForCatch(route, request, notification.item.body))
                     return false;
@@ -207,7 +207,7 @@ async function processNotification(squarePath, notification, opts) {
                     await transitionNotifyLease(square, notification.recipient, notification.item.index, leaseId, 'claimed');
                     releaseLease = true;
                 }
-                recordWakeAttempt({
+                await recordWakeAttempt({
                     attention,
                     routeKind: route.kind,
                     outcome: outcome.outcome,
@@ -224,7 +224,7 @@ async function processNotification(squarePath, notification, opts) {
                     releaseLease = true;
             },
             invalidate: async (route) => {
-                retireWakeRoute(route, { env, at: now() });
+                await retireWakeRoute(route, { env, at: now() });
             },
         });
     }
@@ -257,10 +257,10 @@ export function wakeNotifierForSquare(squarePath, env = process.env) {
     };
 }
 /** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery = deriveDeliveryModel) {
+export async function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery = deriveDeliveryModel) {
     const delivery = deriveDelivery(state);
     const pending = pendingDeliveriesFromState(state, delivery);
-    const evidence = wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery);
+    const evidence = await wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery);
     const indexes = new Set();
     for (const recipient of pending) {
         for (const note of recipient.notifications) {
@@ -288,7 +288,7 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
     finally {
         await closeOpenSquare(square);
     }
-    const selected = pendingNotificationSweepFromState(squarePath, state, now, env, limit);
+    const selected = await pendingNotificationSweepFromState(squarePath, state, now, env, limit);
     const workerPath = fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url));
     for (const actIndex of selected) {
         (opts.launchWorker ?? launchWorker)(workerPath, ['--location', squarePath, '--act-index', String(actIndex)]);

package/dist/presented.d.ts

@@ -6,16 +6,8 @@ export interface PresentedAttention {
     actIndex: number;
 }
 export declare function presentedPath(env?: NodeJS.ProcessEnv): string;
-/** Read the current presentation facts once for a derived evidence projection. */
-export declare function readPresentedAttentions(env?: NodeJS.ProcessEnv, now?: number): PresentedAttention[];
-export declare function hasPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;
-/** True when any current participant owner has already received this attention. */
-export declare function hasPresentedAttention(squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;
-/** Record presentation by a transport that delivered the bounded attention body. */
-export declare function recordPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, at?: number): void;
-/**
- * Serialize presentation only for the affected participants. Delivery runs
- * outside the short ledger-write lock, so unrelated owners never wait on an
- * adapter. A throwing or rejecting callback leaves no row and remains unpresented.
- */
-export declare function presentOnce<T>(sessionId: string, lookup: (sessionId: string) => InboxMembership[] | Promise<InboxMembership[]>, deliver: (inbox: InboxMembership[]) => T | Promise<T>, env?: NodeJS.ProcessEnv, at?: number): Promise<T | undefined>;
+export declare function readPresentedAttentions(env?: NodeJS.ProcessEnv, now?: number): Promise<PresentedAttention[]>;
+export declare function hasPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;
+export declare function hasPresentedAttention(squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;
+export declare function recordPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, at?: number): Promise<void>;
+export declare function presentOnce<T>(sessionId: string, lookup: (sessionId: string) => InboxMembership[] | Promise<InboxMembership[]>, deliver: (inbox: InboxMembership[]) => T | Promise<T>, env?: NodeJS.ProcessEnv, at?: number, signal?: AbortSignal): Promise<T | undefined>;