@astrosheep/square 0.3.30 → 0.3.32

package/dist/cli/observation-commands.js

@@ -4,7 +4,7 @@ import { sessionInbox } from '../inbox.js';
 import { sweepPendingNotifications } from '../notifications.js';
 import { cmdListSquares } from '../list.js';
 import { parseActivityId, sameName } from '../model.js';
-import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, renderPresenceAnchor, withPathOutput, } from '../presentation.js';
+import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, renderPresenceAnchor, withPathOutput, quoteShell, } from '../presentation.js';
 import { actId, nowMs } from '../runtime.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
@@ -114,20 +114,39 @@ function parseTimestamp(value, flag) {
         fail(`Invalid ${flag} timestamp: ${value}`);
     return timestamp;
 }
+function historyContinuationArgs(argv) {
+    const result = [];
+    for (let index = 0; index < argv.length; index++) {
+        const flag = argv[index];
+        if (flag === '--limit' || flag === '--before' || flag === '--after') {
+            index += 1;
+            continue;
+        }
+        result.push(flag);
+        if (flag === '--from' || flag === '--since' || flag === '--at' || flag === '-B' || flag === '-A' || flag === '-C' || flag === '--mention' || flag === '--grep' || flag === '--fixed' || flag === '--order' || flag === '--format') {
+            const value = argv[index + 1];
+            if (value !== undefined) {
+                result.push(value);
+                index += 1;
+            }
+        }
+    }
+    return result;
+}
 function parseHistory(argv, context) {
     const squarePath = requireSquarePath(context);
     const viewer = context.name;
     let lastN = 10;
     let lastNExplicit = false;
-    let before;
     let after;
     let afterIndex;
+    let beforeIndex;
     const atIndexes = [];
     let beforeContext;
     let afterContext;
     let mention;
     let pending = false;
-    let full = false;
+    let noTruncate = false;
     let grep;
     let fixed;
     let order;
@@ -148,18 +167,10 @@ function parseHistory(argv, context) {
             lastNExplicit = true;
             index += 1;
         }
-        else if (flag === '--all') {
-            lastN = null;
-            lastNExplicit = true;
-        }
         else if (flag === '--from') {
             participants.push(...parseNameList(requireValue(argv, index, flag), flag));
             index += 1;
         }
-        else if (flag === '--until') {
-            before = parseTimestamp(requireValue(argv, index, flag), flag);
-            index += 1;
-        }
         else if (flag === '--since') {
             after = parseTimestamp(requireValue(argv, index, flag), flag);
             index += 1;
@@ -168,6 +179,10 @@ function parseHistory(argv, context) {
             afterIndex = parseActRef(requireValue(argv, index, flag), flag);
             index += 1;
         }
+        else if (flag === '--before') {
+            beforeIndex = parseActRef(requireValue(argv, index, flag), flag);
+            index += 1;
+        }
         else if (flag === '--at') {
             const values = requireValue(argv, index, flag).split(',');
             if (values.some((value) => value === ''))
@@ -189,8 +204,8 @@ function parseHistory(argv, context) {
             afterContext = context;
             index += 1;
         }
-        else if (flag === '--full')
-            full = true;
+        else if (flag === '--no-truncate')
+            noTruncate = true;
         else if (flag === '--mention') {
             mention = requireValue(argv, index, flag);
             index += 1;
@@ -227,29 +242,37 @@ function parseHistory(argv, context) {
         fail('--grep and --fixed cannot be combined.');
     if (grep === '' || fixed === '')
         fail('--grep and --fixed require non-empty text.');
+    if (beforeIndex !== undefined && afterIndex !== undefined)
+        fail('--before and --after cannot be combined.');
     if (!lastNExplicit && (atIndexes.length > 0 || pending))
         lastN = null;
     return {
         lastN,
         participants,
-        before,
         after,
         afterIndex,
+        beforeIndex,
         atIndexes: atIndexes.length === 0 ? undefined : atIndexes,
         beforeContext,
         afterContext,
         mention,
         pending,
         viewer,
-        full,
+        noTruncate,
         grep,
         fixed,
         order,
         format,
         json,
+        continuationArgs: historyContinuationArgs(argv),
     };
 }
-function renderFields(sayNumbers, item, fields) {
+function historyContinuationCommand(options, squarePath, direction, index) {
+    const prefix = options.viewer === undefined ? commandPrefix(squarePath) : participantCommandPrefix(squarePath, options.viewer);
+    const args = [...(options.continuationArgs ?? []), direction, actId(index), '--limit', String(options.lastN ?? 10)];
+    return `${prefix} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
+}
+function renderFields(sayNumbers, item, fields, perception) {
     return fields.map((field) => {
         switch (field) {
             case 'id': return actId(item.index);
@@ -258,14 +281,14 @@ function renderFields(sayNumbers, item, fields) {
             case 'ts':
             case 'at': return formatTimestamp(item.at);
             case 'kind': return item.kind;
-            case 'body': return 'body' in item && typeof item.body === 'string' ? item.body.replace(/\s+/g, ' ').trim() : '';
+            case 'body': return perception === 'presence' ? '' : 'body' in item && typeof item.body === 'string' ? item.body.replace(/\s+/g, ' ').trim() : '';
             case 'number': return item.kind === 'say' ? String(sayNumbers[item.index]) : '';
             case 'reply': return item.kind === 'say' && item.reply !== undefined ? actId(item.reply) : '';
             default: return '';
         }
     }).join('\t');
 }
-function jsonLine(sayNumbers, item) {
+function jsonLine(sayNumbers, item, perception) {
     const act = item;
     return JSON.stringify({
         id: actId(item.index),
@@ -274,15 +297,15 @@ function jsonLine(sayNumbers, item) {
         author: act.actor ?? null,
         at: act.at,
         ts: formatTimestamp(act.at),
-        body: 'body' in act && typeof act.body === 'string' ? act.body : '',
+        body: perception === 'presence' ? '' : 'body' in act && typeof act.body === 'string' ? act.body : '',
         number: act.kind === 'say' ? sayNumbers[act.index] : null,
         reach: act.kind === 'say' ? act.reach ?? null : null,
         reply: act.kind === 'say' && act.reply !== undefined ? actId(act.reply) : null,
     });
 }
-function renderHistoryProjection(projection, visible, full, squarePath, viewer, mode) {
+function renderHistoryProjection(projection, visible, noTruncate, squarePath, viewer, mode) {
     const shown = visible.filter((activity) => activity.kind === 'say' || activity.kind === 'done');
-    const preview = full ? undefined : 200;
+    const preview = noTruncate ? undefined : 200;
     const chunks = [];
     for (const activity of shown) {
         const options = {
@@ -302,7 +325,7 @@ function renderHistoryProjection(projection, visible, full, squarePath, viewer,
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';
     if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && activity.body.length > preview && (mode === 'archive' || activity.perception === 'full'))) {
-        chunks.push(`» ${commandPrefix(squarePath)} history --full`);
+        chunks.push(`» ${commandPrefix(squarePath)} history --no-truncate`);
     }
     return chunks.join('\n\n');
 }
@@ -312,29 +335,41 @@ export const historyCommand = {
         const squarePath = requireSquarePath(context);
         const square = await openSquare(squarePath, { clock: nowMs });
         try {
-            const projection = await historyPresentation(square, options);
+            // Keep the projection chronological; pagination chooses a stable edge,
+            // then --order only changes how the selected page is displayed.
+            const projection = await historyPresentation(square, { ...options, order: 'asc' });
             let events = [...projection.activities];
             const searching = options.grep !== undefined || options.fixed !== undefined;
             const totalMatches = searching ? events.length : 0;
             if (options.lastN != null) {
-                events = options.order === 'desc'
+                events = options.afterIndex !== undefined
                     ? events.slice(0, options.lastN)
                     : events.slice(-options.lastN);
             }
+            if (options.order === 'desc')
+                events.reverse();
             if (options.json)
-                return events.map((item) => jsonLine(projection.sayNumbers, item)).join('\n') + (events.length > 0 ? '\n' : '');
+                return events.map((item) => jsonLine(projection.sayNumbers, item, item.perception)).join('\n') + (events.length > 0 ? '\n' : '');
             if (options.format !== undefined && options.format.length > 0) {
-                return events.map((item) => renderFields(projection.sayNumbers, item, options.format)).join('\n') + (events.length > 0 ? '\n' : '');
+                return events.map((item) => renderFields(projection.sayNumbers, item, options.format, item.perception)).join('\n') + (events.length > 0 ? '\n' : '');
             }
             const pattern = options.grep ?? options.fixed;
             const anonymous = options.viewer === undefined;
-            const archive = (options.atIndexes !== undefined && options.atIndexes.length > 0)
-                || (options.lastN == null && options.full === true)
-                || anonymous;
+            const archive = anonymous;
             const output = pattern === undefined || pattern === ''
-                ? renderHistoryProjection(projection, events, options.full === true || anonymous, squarePath, options.viewer ?? '', archive ? 'archive' : 'ambient')
-                : renderGrepActivitiesView(events, totalMatches, options.full, squarePath, pattern, options.fixed !== undefined);
-            return withPathOutput(squarePath, output, { participantCount: projection.participantCount });
+                ? renderHistoryProjection(projection, events, options.noTruncate === true, squarePath, options.viewer ?? '', archive ? 'archive' : 'ambient')
+                : renderGrepActivitiesView(events, totalMatches, options.noTruncate, squarePath, pattern, options.fixed !== undefined, (item) => projection.activities.find((candidate) => candidate.index === item.index)?.perception ?? 'full');
+            const publicEvents = events.filter((item) => item.kind === 'say' || item.kind === 'done');
+            const allPublic = projection.activities.filter((item) => item.kind === 'say' || item.kind === 'done');
+            const pageMin = publicEvents.length === 0 ? undefined : Math.min(...publicEvents.map((item) => item.index));
+            const pageMax = publicEvents.length === 0 ? undefined : Math.max(...publicEvents.map((item) => item.index));
+            const hasMore = options.lastN != null && publicEvents.length > 0 && (options.afterIndex !== undefined
+                ? allPublic.some((item) => item.index > (pageMax ?? options.afterIndex))
+                : allPublic.some((item) => item.index < (pageMin ?? Infinity)));
+            const cursorDirection = options.afterIndex !== undefined ? '--after' : '--before';
+            const cursorIndex = cursorDirection === '--after' ? Math.max(...publicEvents.map((item) => item.index)) : Math.min(...publicEvents.map((item) => item.index));
+            const continuation = hasMore ? `\n\n» ${historyContinuationCommand(options, squarePath, cursorDirection, cursorIndex)}` : '';
+            return withPathOutput(squarePath, output + continuation, { participantCount: projection.participantCount });
         }
         finally {
             await closeOpenSquare(square);
@@ -428,7 +463,7 @@ export const statusCommand = {
                 : [`  ${visible.replace(/\n/g, '\n  ')}`];
             if (visible.includes('more chars') && result.latestAct !== undefined) {
                 const prefix = context.name === undefined ? commandPrefix(squarePath) : participantCommandPrefix(squarePath, context.name);
-                latest.push(`» ${prefix} history --at ${actId(result.latestAct)} -C 2 --full`);
+                latest.push(`» ${prefix} history --at ${actId(result.latestAct)} -C 2 --no-truncate`);
             }
             const output = [
                 `${result.activeCount} active · ${result.doneCount} done · cap ${cap} · throttle ${result.throttlePerMinute === undefined ? 'none' : `${result.throttlePerMinute}/min`}`,

package/dist/cli/square-commands.js

@@ -1,13 +1,15 @@
 import { cmdActivity } from '../activity.js';
 import { formatActivityId, formatHardCap, parseActivityId, } from '../model.js';
 import { participantCommandPrefix, participantIdentity, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
-import { hasAutomaticDeliveryIdentity, localParticipantOwner, recordLocalDone, recordLocalJoin, } from '../registry.js';
-import { sweepPendingNotifications, wakeNotifierForSquare } from '../notifications.js';
+import { hasAutomaticDeliveryIdentity, } from '../registry.js';
+import { createHostLedgerPort } from '../host-ledger-file-adapter.js';
+import { projectLocalParticipantBinding, sessionIdsFromEnvironment } from '../square-projections.js';
 import { nowMs } from '../runtime.js';
 import { createSquare, openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { openParticipant, Square } from '../square-wiring.js';
 import { entryPresentation, eventPresentation } from '../views.js';
+import { createDefaultWakeTransport } from '../notifications.js';
 import { fail, parseHardCap, parsePositiveInteger, readStdin, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
 function parseBuild(argv) {
     const options = { force: false, hardCap: null };
@@ -84,13 +86,19 @@ export const joinCommand = {
         const beforeSquare = await openSquare(squarePath, { clock: nowMs });
         const before = await entryPresentation(beforeSquare, intent.name, intent.lastN);
         await closeOpenSquare(beforeSquare);
-        const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
+        const hostLedger = createHostLedgerPort();
+        const square = await Square.at({ path: squarePath, clock: nowMs, hostLedger, wakeTransport: await createDefaultWakeTransport(hostLedger, nowMs) });
         try {
+            const reconnect = before.joined
+                && await projectLocalParticipantBinding({
+                    hostLedger: createHostLedgerPort(),
+                    location: squarePath,
+                    participant: intent.name,
+                    sessionIds: sessionIdsFromEnvironment(),
+                }) !== undefined;
             const participant = await square.join(intent.name);
             const joinedName = participant.name;
             const isRejoin = before.joined;
-            const reconnect = isRejoin
-                && await localParticipantOwner(squarePath, joinedName) !== undefined;
             if (isRejoin && !intent.kick && !reconnect) {
                 fail([
                     `✕ ${participantIdentity(joinedName)} shoos you out of the square`,
@@ -102,8 +110,7 @@ export const joinCommand = {
             const afterSquare = await openSquare(squarePath, { clock: nowMs });
             const after = await entryPresentation(afterSquare, joinedName, intent.lastN);
             await closeOpenSquare(afterSquare);
-            await recordLocalJoin(joinedName, squarePath);
-            await sweepPendingNotifications(squarePath);
+            await square.reconcileBinding().catch(() => undefined);
             const activities = after.recentActivities.map((event) => renderAmbientEvent(event, joinedName, {
                 now: nowMs(),
                 preview: intent.lastN === null ? undefined : 200,
@@ -175,7 +182,6 @@ export const expressCommand = {
     parse: parseActivity,
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        await sweepPendingNotifications(squarePath);
         const body = await resolveBody(intent.activity);
         const reachArg = intent.reach === 'bell' ? ' --bell' : '';
         await cmdActivity(squarePath, intent.name, body, (value) => value, {
@@ -275,12 +281,12 @@ export const doneCommand = {
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         const body = (await resolveBody(intent.body ?? (process.stdin.isTTY ? '' : '-'))).replace(/\r\n/g, '\n').trim();
-        const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
+        const square = await Square.at({ path: squarePath, clock: nowMs });
         const participant = await square.join(intent.name);
         const result = await participant.done(body);
+        await square.reconcileBinding();
         await square.close();
         const name = result.activity.actor;
-        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 });
@@ -296,7 +302,7 @@ export const holdCommand = {
     parse: parseHold,
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
+        const square = await Square.at({ path: squarePath, clock: nowMs });
         try {
             const participant = await square.join(intent.name);
             const result = await participant.hold((await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim());
@@ -320,7 +326,7 @@ export const resumeCommand = {
     },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
+        const square = await Square.at({ path: squarePath, clock: nowMs });
         try {
             const participant = await square.join(intent.name);
             const result = await participant.resume();

package/dist/codex-hook.d.ts

@@ -1,10 +1,11 @@
 import type { InboxMembership } from './model.js';
+import type { WakeAdapter } from './delivery.js';
 export interface CodexHookInput {
     session_id?: unknown;
     hook_event_name?: unknown;
     cwd?: unknown;
     source?: unknown;
 }
-export declare function codexHookResponse(input: CodexHookInput, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<object | undefined>;
+export declare function codexHookResponse(input: CodexHookInput, lookup?: (sessionId: string, env?: NodeJS.ProcessEnv) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv, deliveryAdapters?: WakeAdapter[]): Promise<object | undefined>;
 export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
 export declare function runCodexHookAsync(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/codex-hook.js

@@ -2,11 +2,12 @@ import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
 import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
 import { clearCodexBoundary, recordCodexBoundary } from './codex-boundary-state.js';
+import { sweepPrivilegedPending } from './notifications.js';
 const CODEX_HOOK_EVENTS = {
     PostToolUse: 'PostToolUse',
     Stop: 'Stop',
 };
-export async function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
+export async function codexHookResponse(input, lookup = sessionInbox, env = process.env, deliveryAdapters) {
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (typeof input.hook_event_name !== 'string')
@@ -15,9 +16,11 @@ export async function codexHookResponse(input, lookup = sessionInbox, env = proc
     if (hookEventName === undefined)
         return undefined;
     await recordCodexBoundary(input.session_id, hookEventName === 'Stop' ? 'Stop' : 'non-stop', env);
-    return presentPendingAtBoundary(input.session_id, (context) => hookEventName === 'Stop'
+    const response = await presentPendingAtBoundary(input.session_id, (context) => hookEventName === 'Stop'
         ? { systemMessage: context }
         : { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }, lookup, env);
+    await sweepPrivilegedPending(typeof input.cwd === 'string' ? input.cwd : process.cwd(), env, deliveryAdapters).catch(() => undefined);
+    return response;
 }
 export async function runCodexHook(inputText, env = process.env) {
     let input;

package/dist/codex-queue.js

@@ -36,7 +36,7 @@ export class CodexQueueAdapter {
     async dispatch(address, payload, beforeSend) {
         const threadId = address.threadId?.trim();
         if (!threadId) {
-            return { outcome: 'unavailable', signature: 'invalid_address', message: 'Codex route has no thread id.' };
+            return { outcome: 'unavailable', signature: 'invalid_address', message: 'Codex route has no thread id.', routeStale: true };
         }
         const env = this.opts.env ?? process.env;
         if (!await codexQueueEligible(threadId, env)) {

package/dist/decisions.js

@@ -274,11 +274,11 @@ export function coreActivities(squareState, opts, suppliedDelivery) {
     }
     if (opts.afterIndex != null)
         acts = acts.filter((act) => act.index > opts.afterIndex);
+    if (opts.beforeIndex != null)
+        acts = acts.filter((act) => act.index < opts.beforeIndex);
     if (canonicalParticipants.length > 0) {
         acts = acts.filter((act) => act.actor !== undefined && canonicalParticipants.some((participant) => sameName(participant, act.actor)));
     }
-    if (opts.before != null)
-        acts = acts.filter((act) => act.at < opts.before);
     if (opts.after != null)
         acts = acts.filter((act) => act.at > opts.after);
     if (opts.mention != null) {

package/dist/delivery-health.d.ts

@@ -1,5 +1,5 @@
 import { type DirectedNotificationRoute } from './delivery.js';
-import type { WakeAttempt } from './wake-attempts.js';
+import type { WakeAttempt } from './square-projections.js';
 export type DeliveryHealthKind = 'awaiting' | 'wake-accepted' | 'wake-unknown' | 'presented-not-delivered' | 'unreachable';
 export interface DeliveryHealthItem {
     squarePath: string;

package/dist/delivery-operations.d.ts

@@ -0,0 +1,25 @@
+import { type SquareState } from './model.js';
+import type { HostLedgerPort, PresenceRecord, 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 sweepPending(input: {
+    readonly artifact: SquareArtifactPort;
+    readonly hostLedger: HostLedgerPort;
+    readonly location: string;
+    readonly now: number;
+    readonly graceMs: number;
+    readonly limit: number;
+}): Promise<number[]>;
+export declare function sweepPendingFromState(input: {
+    readonly state: SquareState;
+    readonly hostLedger: HostLedgerPort;
+    readonly location: string;
+    readonly now: number;
+    readonly graceMs: number;
+    readonly limit: number;
+    readonly deriveDelivery?: (snapshot: SquareState) => ReturnType<typeof deriveDeliveryModel>;
+}): Promise<number[]>;

package/dist/delivery-operations.js

@@ -0,0 +1,207 @@
+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 { retireWakeRouteFromArtifact } from './routes.js';
+export async function observeSquare(input) {
+    const snapshot = await input.artifact.read();
+    const delivery = deriveDeliveryModel(snapshot.state);
+    let rows = [];
+    if (input.hostLedger !== undefined) {
+        try {
+            rows = await input.hostLedger.listPresence({ location: input.location, scopes: ['user', 'local'], now: input.now });
+        }
+        catch {
+            rows = [];
+        }
+    }
+    const bindings = rows.map((record) => ({
+        location: record.location,
+        participant: record.participant,
+        sessionId: record.session,
+        channel: record.channel,
+        ...(record.route === undefined ? {} : { route: { location: record.location, participant: record.participant, sessionId: record.session, channel: record.channel, kind: record.route.kind, address: { ...record.route.address }, updatedAt: record.updatedAt ?? 0 } }),
+        updatedAt: record.updatedAt ?? 0,
+    }));
+    return { ...(input.location === undefined ? {} : { location: input.location }), version: snapshot.version, state: snapshot.state, pending: delivery.joinedRecipients().map((recipient) => ({ recipient, notifications: delivery.pendingFor(recipient) })), bindings };
+}
+export async function reconcileBinding(input) {
+    return input.hostLedger.reconcileBinding({ artifact: input.artifact, scopes: input.scopes, now: input.now });
+}
+export async function deliverPending(input) {
+    const observation = await observeSquare({ artifact: input.artifact, hostLedger: input.hostLedger, location: input.location, now: input.now });
+    const routes = (observation.state.routes ?? []).map((route) => ({
+        location: route.location,
+        participant: route.participant,
+        session: route.sessionId,
+        channel: route.channel,
+        route: { kind: route.kind, address: route.address },
+        updatedAt: route.updatedAt,
+    }));
+    let attempted = 0;
+    let accepted = 0;
+    let failed = 0;
+    let unknown = 0;
+    let notCapable = 0;
+    for (const membership of observation.pending) {
+        for (const notification of membership.notifications) {
+            const candidates = routes.filter((route) => nameKey(route.participant) === nameKey(membership.recipient));
+            if (candidates.length === 0) {
+                notCapable += 1;
+                continue;
+            }
+            if (input.activity !== undefined) {
+                const requested = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
+                if (requested === undefined || requested !== notification.item.index)
+                    continue;
+            }
+            let acceptedForAttention = false;
+            try {
+                const prior = await input.hostLedger.listWakeAttempts({ attention: { squarePath: input.location, actIndex: notification.item.index, recipient: membership.recipient }, now: input.now });
+                acceptedForAttention = prior.some((attempt) => attempt.outcome === 'accepted');
+            }
+            catch { /* capability is handled by the route-level probe */ }
+            if (acceptedForAttention)
+                continue;
+            for (const route of candidates) {
+                const activity = formatActivityId(notification.item.index);
+                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 };
+                if (input.transport.probe !== undefined) {
+                    try {
+                        const probe = await input.transport.probe(requestRoute);
+                        if (probe === false || (typeof probe === 'object' && probe.outcome === 'not-capable')) {
+                            notCapable += 1;
+                            continue;
+                        }
+                    }
+                    catch {
+                        notCapable += 1;
+                        continue;
+                    }
+                }
+                let leaseId = randomUUID();
+                let lease;
+                try {
+                    lease = await input.hostLedger.claimWakeDispatch({ attention, leaseId, leaseMs, session: route.session, at: input.now });
+                }
+                catch {
+                    notCapable += 1;
+                    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;
+                }
+                if (lease.type !== 'acquired')
+                    continue;
+                let attempts;
+                try {
+                    attempts = await input.hostLedger.listWakeAttempts({ attention, session: route.session, now: input.now });
+                }
+                catch {
+                    notCapable += 1;
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now }).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;
+                }
+                const attemptN = attempts.reduce((highest, record) => Math.max(highest, record.attemptN ?? 0), 0) + 1;
+                const request = { location: input.location, participant: membership.recipient, activity, 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 });
+                if (claim.status !== 'acquired') {
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now });
+                    if (claim.status === 'degraded')
+                        notCapable += 1;
+                    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 });
+                if (!dispatching) {
+                    await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session, at: input.now });
+                    continue;
+                }
+                try {
+                    outcome = await Promise.race([input.transport.attempt(request, leaseMs), new Promise((resolve) => setTimeout(() => resolve({ outcome: 'unknown', diagnostic: 'transport timeout' }), leaseMs))]);
+                }
+                catch (error) {
+                    outcome = { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };
+                }
+                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;
+                    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;
+                    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 });
+                if (outcome.outcome === 'accepted') {
+                    accepted += 1;
+                    acceptedForAttention = true;
+                    break;
+                }
+                if (outcome.outcome === 'failed')
+                    failed += 1;
+                else
+                    unknown += 1;
+            }
+        }
+    }
+    return { attempted, accepted, failed, unknown, notCapable };
+}
+export function selectPendingWakeActivities(state, routes, attempts, now, graceMs, limit, delivery = deriveDeliveryModel(state)) {
+    const selected = new Set();
+    for (const membership of delivery.joinedRecipients()) {
+        for (const notification of delivery.pendingFor(membership)) {
+            if (now - notification.item.at <= graceMs)
+                continue;
+            if (attempts.some((attempt) => attempt.attention.actIndex === notification.item.index && nameKey(attempt.attention.recipient) === nameKey(membership) && attempt.outcome === 'accepted'))
+                continue;
+            const eligible = routes.some((binding) => {
+                if (binding.route === undefined || nameKey(binding.participant) !== nameKey(membership))
+                    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);
+            });
+            if (eligible)
+                selected.add(notification.item.index);
+        }
+    }
+    return [...selected].sort((left, right) => left - right).slice(0, Math.max(0, limit));
+}
+export async function sweepPending(input) {
+    const { state } = await input.artifact.read();
+    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 }));
+    let records = [];
+    try {
+        records = await input.hostLedger.listWakeAttempts({ now: input.now });
+    }
+    catch {
+        records = [];
+    }
+    const attempts = records.flatMap((record) => {
+        const index = parseActivityId(record.activity);
+        if (index === undefined || record.routeKind === undefined || typeof record.attemptN !== 'number')
+            return [];
+        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);
+}

package/dist/delivery.d.ts

@@ -35,6 +35,7 @@ export type WakeDispatchResult = {
     message: string;
     diagnostic?: unknown;
     retainRoute?: boolean;
+    routeStale?: boolean;
 } | {
     outcome: 'cancelled';
 };