@astrosheep/square 0.3.29 → 0.3.31

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,8 +1,10 @@
 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 { sweepPendingNotifications } from '../notifications.js';
 import { nowMs } from '../runtime.js';
 import { createSquare, openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
@@ -84,13 +86,18 @@ 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 square = await Square.at({ path: squarePath, clock: 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,7 +109,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 square.reconcileBinding();
             await sweepPendingNotifications(squarePath);
             const activities = after.recentActivities.map((event) => renderAmbientEvent(event, joinedName, {
                 now: nowMs(),
@@ -275,12 +282,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 +303,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 +327,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

@@ -5,6 +5,6 @@ export interface CodexHookInput {
     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): 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/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,124 @@
+import { randomUUID } from 'node:crypto';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { deriveDeliveryModel } from './delivery.js';
+import { isWakeRouteAttemptable } from './square-projections.js';
+export async function observeSquare(input) {
+    const snapshot = await input.artifact.read();
+    const delivery = deriveDeliveryModel(snapshot.state);
+    const rows = input.hostLedger === undefined ? [] : await input.hostLedger.listPresence({ location: input.location, scopes: ['user', 'local'], now: input.now });
+    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 = (await input.hostLedger.listPresence({ location: input.location, scopes: ['user'], now: input.now })).filter((binding) => binding.route !== undefined);
+    let attempted = 0;
+    let accepted = 0;
+    let failed = 0;
+    let unknown = 0;
+    for (const membership of observation.pending) {
+        for (const notification of membership.notifications) {
+            const candidates = routes.filter((route) => route.participant.toLocaleLowerCase() === membership.recipient.toLocaleLowerCase());
+            if (input.activity !== undefined) {
+                const requested = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
+                if (requested === undefined || requested !== notification.item.index)
+                    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;
+                let leaseId = randomUUID();
+                let lease = await input.hostLedger.claimWakeDispatch({ attention, leaseId, leaseMs, session: route.session, at: input.now });
+                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 });
+                    leaseId = randomUUID();
+                    lease = await input.hostLedger.claimWakeDispatch({ attention, leaseId, leaseMs, session: route.session, at: input.now });
+                }
+                if (lease.type !== 'acquired')
+                    continue;
+                const attempts = await input.hostLedger.listWakeAttempts({ attention, session: route.session, now: input.now });
+                const attemptN = attempts.reduce((highest, record) => Math.max(highest, record.attemptN ?? 0), 0) + 1;
+                const request = { location: input.location, participant: membership.recipient, activity, route: { location: route.location, participant: route.participant, sessionId: route.session, channel: route.channel, kind: route.route.kind, address: { ...route.route.address }, updatedAt: route.updatedAt ?? 0 } };
+                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 });
+                    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 === 'failed' && outcome.unavailable) {
+                    await input.transport.invalidate?.(request);
+                    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;
+                else if (outcome.outcome === 'failed')
+                    failed += 1;
+                else
+                    unknown += 1;
+            }
+        }
+    }
+    return { attempted, accepted, failed, unknown };
+}
+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;
+            const eligible = routes.some((binding) => {
+                if (binding.route === undefined || binding.participant.toLocaleLowerCase() !== membership.toLocaleLowerCase())
+                    return false;
+                const matching = attempts.filter((attempt) => attempt.session === binding.session && attempt.attention.squarePath === binding.location && attempt.attention.recipient.toLocaleLowerCase() === membership.toLocaleLowerCase() && 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, records] = await Promise.all([input.hostLedger.listPresence({ location: input.location, scopes: ['user'], now: input.now }), input.hostLedger.listWakeAttempts({ now: input.now })]);
+    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/help.js

@@ -43,7 +43,7 @@ const COMMANDS = [
     {
         names: ['history'], usage: '[--as <name>] history [filters] [output]', usesSquare: true, group: 'participant',
         summary: 'Read or search the archive without changing what you have caught.',
-        details: ['Filters:', '  --from <names>                  Match activities from participants.', '  --since <time>, --until <time>  Match a time window.', '  --grep <regex> | --fixed <s>    Search activity ids, participants, and original bodies.', '  --mention <name>                Match direct attention for a participant.', '  --pending                       Match attention waiting for --as <name>.', '  --at <ids>                      Center on comma-separated activity ids; may repeat.', '  -B, -A, -C <N>                 Set non-negative context around every --at coordinate.', '  --after <id>                    Match activities after an id.', '', 'Results:', '  --limit <N> | --all             Bound the newest matches (default 10).', '  --order <asc|desc>              Set display order (default oldest first).', '', 'Output:', '  --full  --json  --format <fields>', '  Without --as, the default view shows complete activity bodies.'],
+        details: ['Filters:', '  --from <names>                  Match activities from participants.', '  --since <time>                  Match activities after a time.', '  --grep <regex> | --fixed <s>    Search activity ids, participants, and original bodies.', '  --mention <name>                Match direct attention for a participant.', '  --pending                       Match attention waiting for --as <name>.', '  --at <ids>                      Center on comma-separated activity ids; may repeat.', '  -B, -A, -C <N>                 Set non-negative context around every --at coordinate.', '  --before <id>                   Read the page immediately before an activity.', '  --after <id>                    Read the page immediately after an activity.', '', 'Results:', '  --limit <N>                     Page size (default 10).', '  --order <asc|desc>              Set display order (default oldest first).', '', 'Output:', '  --no-truncate  --json  --format <fields>', '  Bodies are previews by default; --no-truncate expands them. --as keeps participant perception.'],
     },
     { names: ['status'], usage: '[--as <name>] status', usesSquare: true, group: 'participant', summary: 'Show who is present and what happened most recently.' },
     { names: ['participants'], usage: 'participants', usesSquare: true, group: 'host', summary: 'Show the full participant roster and current states.' },

package/dist/host-ledger-file-adapter.d.ts

@@ -0,0 +1,34 @@
+import type { HostLedgerPort, HostLedgerScope, PresenceRecord, PresenceKey, PresenceLookup, PresenceResult, EvidenceRecord, EvidenceClaim, EvidenceRelease, EvidenceLookup, EvidenceGc, ClaimResult, ReconcileBindingInput, ReconcileBindingResult, WakeDispatchClaim, WakeDispatchClaimInput, WakeDispatchReleaseInput, WakeDispatchTransitionInput, WakeAttemptLookup } from './host-ledger.js';
+export interface HostLedgerFileAdapterOptions {
+    userPath?: string;
+    localPath?: string;
+    writableScope?: HostLedgerScope;
+    readableScopes?: readonly HostLedgerScope[];
+    claimsPath?: string;
+    now?: () => number;
+}
+export declare class FileHostLedgerPort implements HostLedgerPort {
+    private readonly user;
+    private readonly local;
+    private readonly writable;
+    private readonly readable;
+    private readonly claims;
+    private readonly clock;
+    constructor(o?: HostLedgerFileAdapterOptions);
+    private file;
+    ensurePresence(i: PresenceRecord, scope?: HostLedgerScope): Promise<PresenceResult>;
+    removePresence(i: PresenceKey): Promise<void>;
+    listPresence(i?: PresenceLookup): Promise<readonly PresenceRecord[]>;
+    claimWakeDispatch(i: WakeDispatchClaimInput): Promise<WakeDispatchClaim>;
+    transitionWakeDispatch(i: WakeDispatchTransitionInput): Promise<boolean>;
+    releaseWakeDispatch(i: WakeDispatchReleaseInput): Promise<void>;
+    listWakeAttempts(i?: WakeAttemptLookup): Promise<readonly EvidenceRecord[]>;
+    appendWakeAttempt(i: EvidenceRecord): Promise<void>;
+    claimEvidence(i: EvidenceClaim): Promise<ClaimResult>;
+    releaseEvidence(i: EvidenceRelease): Promise<void>;
+    appendEvidence(i: EvidenceRecord): Promise<void>;
+    listEvidence(i?: EvidenceLookup): Promise<readonly EvidenceRecord[]>;
+    gcEvidence(i: EvidenceGc): Promise<void>;
+    reconcileBinding(i?: ReconcileBindingInput): Promise<ReconcileBindingResult>;
+}
+export declare function createHostLedgerPort(o?: HostLedgerFileAdapterOptions): HostLedgerPort;