@astrosheep/square 0.3.31 → 0.3.33

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

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

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

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

package/dist/activity.js

@@ -11,6 +11,8 @@ import { Square } from './square-wiring.js';
 import { activityPresentation, resolveParticipant } from './views.js';
 import { formatActivityId } from './square-core.js';
 import { formatTimestamp } from './time.js';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
+import { createDefaultWakeTransport } from './notifications.js';
 function draftDirFor(squarePath) {
     return path.join(path.dirname(squarePath), 'drafts');
 }
@@ -66,7 +68,9 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
     const noWait = opts.noWait ?? false;
     const reach = opts.reach === 'bell' ? 'bell' : undefined;
     let announcedWait;
-    const square = await Square.at({ path: squarePath, clock: nowMs });
+    const ledgerRoot = process.env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(process.env.SQUARE_REGISTRY);
+    const hostLedger = createHostLedgerPort({ userPath: process.env.SQUARE_HOST_LEDGER_USER ?? ledgerRoot, localPath: process.env.SQUARE_HOST_LEDGER_LOCAL ?? ledgerRoot });
+    const square = await Square.at({ path: squarePath, clock: nowMs, hostLedger, wakeTransport: await createDefaultWakeTransport(hostLedger, nowMs) });
     try {
         const participant = await square.join(name);
         while (true) {
@@ -80,11 +84,8 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
                     ...(reach === undefined ? {} : { reach }),
                     ...(opts.reply === undefined ? {} : { reply: formatActivityId(opts.reply) }),
                 });
-                try {
-                }
-                catch {
-                    // Compatibility wake is post-commit and cannot undo the activity.
-                }
+                if (result.delivery?.notCapable)
+                    process.stderr.write(`! wake not-capable: ${result.delivery.notCapable}\n`);
                 const freshSquare = await openSquare(squarePath, { clock: nowMs });
                 const fresh = await activityPresentation(freshSquare, knownName).finally(() => closeOpenSquare(freshSquare));
                 const headerCount = fresh.participantCount;

package/dist/artifact.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { TextDecoder } from 'node:util';
 import zlib from 'node:zlib';
-import { InternalSquareError, SquareError, } from './model.js';
+import { isWakeRouteKind, InternalSquareError, SquareError, } from './model.js';
 import { parseActivityId } from './square-core.js';
 const SQUARE_MAGIC = Buffer.from('SQUARE01', 'ascii');
 const LENGTH_BYTES = 4;
@@ -138,13 +138,14 @@ function validateActs(value) {
 }
 function validateSquareState(value) {
     if (!isObject(value)
-        || !hasExactKeys(value, ['hardCap', 'preamble', 'warmup', 'acts', 'runtime'], ['throttlePerMinute'])
+        || !hasExactKeys(value, ['hardCap', 'preamble', 'warmup', 'acts', 'runtime'], ['throttlePerMinute', 'routes'])
         || !(value.hardCap === null || (Number.isSafeInteger(value.hardCap) && value.hardCap > 0))
         || (value.throttlePerMinute !== undefined
             && (!Number.isSafeInteger(value.throttlePerMinute) || value.throttlePerMinute <= 0))
         || !isStringArray(value.preamble)
         || !isStringArray(value.warmup)
         || !validateActs(value.acts)
+        || (value.routes !== undefined && (!Array.isArray(value.routes) || !value.routes.every((route) => isObject(route) && isWakeRouteKind(route.kind) && typeof route.location === 'string' && typeof route.participant === 'string' && typeof route.sessionId === 'string' && typeof route.channel === 'string' && isObject(route.address) && Object.values(route.address).every((item) => typeof item === 'string') && typeof route.updatedAt === 'number')))
         || !validateRuntime(value.runtime)) {
         throw invalidArtifact('snapshot schema is malformed.');
     }
@@ -241,6 +242,7 @@ export function createSquareState(options, snippet) {
         preamble: normalizedLines(snippet),
         warmup: normalizedLines(guides.join('\n\n')),
         acts: [],
+        routes: [],
         runtime: emptyRuntimeState(),
     };
 }

package/dist/automatic-session.js

@@ -7,6 +7,7 @@ import { entryPresentation } from './views.js';
 import { automaticParticipant } from './participant-identity.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { projectSessionBindings } from './square-projections.js';
+import { publishWakeRoute, retireWakeRouteFromArtifact, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
 export { automaticParticipant } from './participant-identity.js';
 const providerEnv = {
     codex: 'CODEX_THREAD_ID',
@@ -56,7 +57,17 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         const implicit = await square.implicitJoin(name);
         if (implicit.state === 'done')
             return undefined;
-        await hostLedgerForEnv(env).ensurePresence({ location: squarePath, participant: name, session: sessionId, channel: provider === 'claude' ? 'claude-code' : provider, updatedAt: Date.now() });
+        const route = resolvePrimaryWakeRoute({ location: squarePath, participant: name, sessionId, provider }, env, await defaultWakeRouteCapabilities(hostLedgerForEnv(env)));
+        if (route !== undefined) {
+            const publisher = await openSquare(squarePath, { hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv });
+            try {
+                await publishWakeRoute(publisher.artifact, route, { at: Date.now() });
+            }
+            finally {
+                await closeOpenSquare(publisher);
+            }
+        }
+        await hostLedgerForEnv(env).ensurePresence({ location: squarePath, participant: name, session: sessionId, channel: provider === 'claude' ? 'claude-code' : provider, updatedAt: Date.now() }, 'user');
         await square.reconcileBinding();
         return undefined;
     }
@@ -87,6 +98,13 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
         const participant = await square.join(binding.participant);
         await participant.done();
         await square.reconcileBinding();
+        const cleanup = await openSquare(squarePath);
+        try {
+            await retireWakeRouteFromArtifact(cleanup.artifact, { location: squarePath, participant: binding.participant, sessionId });
+        }
+        finally {
+            await closeOpenSquare(cleanup);
+        }
     }
     finally {
         await square.close();

package/dist/claude-hook.d.ts

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

package/dist/claude-hook.js

@@ -1,6 +1,7 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
 import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
 export async function runClaudeHookAsync(inputText, env = process.env) {
     let input;
     try {
@@ -34,12 +35,15 @@ export async function runClaudeHookAsync(inputText, env = process.env) {
     }
     return runClaudeHook(inputText, env);
 }
-export async function claudeHookResponse(input, lookup = sessionInbox, env = process.env) {
+export async function claudeHookResponse(input, lookup = sessionInbox, env = process.env, deliveryAdapters) {
+    const sweepDeadline = Date.now() + PRIVILEGED_HOOK_BUDGET_MS;
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (input.hook_event_name !== 'PostToolBatch')
         return undefined;
-    return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolBatch', additionalContext: context } }), lookup, env);
+    const response = await presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolBatch', additionalContext: context } }), lookup, env);
+    await sweepPrivilegedPending(typeof input.cwd === 'string' ? input.cwd : process.cwd(), env, deliveryAdapters, sweepDeadline).catch(() => undefined);
+    return response;
 }
 export async function runClaudeHook(inputText, env = process.env) {
     let input;

package/dist/cli/square-commands.js

@@ -4,12 +4,12 @@ import { participantCommandPrefix, participantIdentity, renderEventCli, renderAm
 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';
 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 };
@@ -86,7 +86,8 @@ 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 });
+        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({
@@ -109,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 square.reconcileBinding();
-            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,
@@ -182,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, {

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, env?: NodeJS.ProcessEnv) => 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,13 @@ 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 { PRIVILEGED_HOOK_BUDGET_MS, 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) {
+    const sweepDeadline = Date.now() + PRIVILEGED_HOOK_BUDGET_MS;
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (typeof input.hook_event_name !== 'string')
@@ -15,9 +17,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, sweepDeadline).catch(() => undefined);
+    return response;
 }
 export async function runCodexHook(inputText, env = process.env) {
     let input;

package/dist/codex-queue.d.ts

@@ -22,6 +22,6 @@ export declare class CodexQueueAdapter implements WakeAdapter {
     private readonly opts;
     readonly kind: "codex-queue";
     constructor(opts?: CodexQueueAdapterOptions);
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>): Promise<WakeDispatchResult>;
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number): Promise<WakeDispatchResult>;
 }
 export type { WakeRoute };

package/dist/codex-queue.js

@@ -33,10 +33,12 @@ export class CodexQueueAdapter {
     constructor(opts = {}) {
         this.opts = opts;
     }
-    async dispatch(address, payload, beforeSend) {
+    async dispatch(address, payload, beforeSend, timeoutMs = 5000) {
+        const deadline = Date.now() + timeoutMs;
+        const remainingMs = () => Math.max(0, deadline - Date.now());
         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)) {
@@ -57,8 +59,12 @@ export class CodexQueueAdapter {
                 retainRoute: true,
             };
         }
+        const remaining = remainingMs();
+        if (remaining === 0) {
+            return { outcome: 'unavailable', signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.', retainRoute: true };
+        }
         try {
-            (this.opts.sendQueue ?? sendCodexQueue)({ threadId, message: payload }, { env });
+            (this.opts.sendQueue ?? sendCodexQueue)({ threadId, message: payload }, { env, timeoutMs: remaining });
             return { outcome: 'accepted' };
         }
         catch (error) {

package/dist/delivery-operations.js

@@ -1,11 +1,34 @@
 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';
+async function attemptWakeWithin(transport, request, timeoutMs) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ outcome: 'unknown', diagnostic: 'transport timeout' }), timeoutMs);
+    });
+    try {
+        return await Promise.race([transport.attempt(request, timeoutMs), timeout]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 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 });
+    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,
@@ -21,40 +44,94 @@ export async function reconcileBinding(input) {
 }
 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);
+    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) => route.participant.toLocaleLowerCase() === membership.recipient.toLocaleLowerCase());
+            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 = await input.hostLedger.claimWakeDispatch({ attention, leaseId, leaseMs, session: route.session, at: input.now });
+                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 });
-                    leaseId = randomUUID();
-                    lease = await input.hostLedger.claimWakeDispatch({ attention, leaseId, leaseMs, session: route.session, at: input.now });
+                    continue;
                 }
                 if (lease.type !== 'acquired')
                     continue;
-                const attempts = await input.hostLedger.listWakeAttempts({ attention, session: route.session, now: input.now });
+                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: { location: route.location, participant: route.participant, sessionId: route.session, channel: route.channel, kind: route.route.kind, address: { ...route.route.address }, updatedAt: route.updatedAt ?? 0 } };
+                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;
@@ -64,13 +141,20 @@ export async function deliverPending(input) {
                     continue;
                 }
                 try {
-                    outcome = await Promise.race([input.transport.attempt(request, leaseMs), new Promise((resolve) => setTimeout(() => resolve({ outcome: 'unknown', diagnostic: 'transport timeout' }), leaseMs))]);
+                    outcome = await attemptWakeWithin(input.transport, request, 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) {
-                    await input.transport.invalidate?.(request);
+                    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;
@@ -78,16 +162,19 @@ export async function deliverPending(input) {
                 }
                 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')
+                if (outcome.outcome === 'accepted') {
                     accepted += 1;
-                else if (outcome.outcome === 'failed')
+                    acceptedForAttention = true;
+                    break;
+                }
+                if (outcome.outcome === 'failed')
                     failed += 1;
                 else
                     unknown += 1;
             }
         }
     }
-    return { attempted, accepted, failed, unknown };
+    return { attempted, accepted, failed, unknown, notCapable };
 }
 export function selectPendingWakeActivities(state, routes, attempts, now, graceMs, limit, delivery = deriveDeliveryModel(state)) {
     const selected = new Set();
@@ -95,10 +182,12 @@ export function selectPendingWakeActivities(state, routes, attempts, now, graceM
         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 || binding.participant.toLocaleLowerCase() !== membership.toLocaleLowerCase())
+                if (binding.route === undefined || nameKey(binding.participant) !== nameKey(membership))
                     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);
+                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)
@@ -112,7 +201,14 @@ export async function sweepPending(input) {
     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 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')

package/dist/delivery.d.ts

@@ -35,12 +35,13 @@ export type WakeDispatchResult = {
     message: string;
     diagnostic?: unknown;
     retainRoute?: boolean;
+    routeStale?: boolean;
 } | {
     outcome: 'cancelled';
 };
 export interface WakeAdapter {
     readonly kind: WakeRouteKind;
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>): Promise<WakeDispatchResult>;
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number): Promise<WakeDispatchResult>;
 }
 export interface RoutedNotification {
     actor: string;

package/dist/host-ledger-file-adapter.js

@@ -116,7 +116,7 @@ export class FileHostLedgerPort {
     catch (error) {
         return { status: 'degraded', error };
     } }
-    async releaseEvidence(i) { const f = this.file('user', 'evidence'), location = await canon(i.location), at = i.now ?? this.clock(); await withFileLock(f + '.lock', LOCK, async () => write(f, (await read(f, at)).filter(x => !(x.kind === i.kind && x.location === location && nameKey(x.participant) === nameKey(i.participant) && x.activity === i.activity && x.session === i.session && x.outcome === 'dispatching')))); }
+    async releaseEvidence(i) { const f = this.file('user', 'evidence'), location = await canon(i.location), at = i.now ?? this.clock(); await withFileLock(f + '.lock', LOCK, async () => write(f, (await read(f, at, true)).filter(x => !(x.kind === i.kind && x.location === location && nameKey(x.participant) === nameKey(i.participant) && x.activity === i.activity && x.session === i.session && x.outcome === 'dispatching')))); }
     async appendEvidence(i) { const f = this.file('user', 'evidence'), r = { ...i, location: await canon(i.location), at: i.at ?? this.clock(), v: 1 }; await withFileLock(f + '.lock', LOCK, async () => { const all = await read(f, r.at, true); const base = all.filter(x => k(x) === k(r)); const replaceable = new Set(base.filter(x => x.outcome === 'dispatching' || (r.attemptN !== undefined && x.attemptN === r.attemptN)).map(x => evidenceKey(x))); await write(f, [...all.filter(x => !(x.outcome === 'dispatching' && k(x) === k(r)) && !replaceable.has(evidenceKey(x))), r]); }); }
     async listEvidence(i = {}) { const loc = i.location === undefined ? undefined : await canon(i.location); return (await read(this.file('user', 'evidence'), i.now ?? this.clock())).filter(r => (!loc || r.location === loc) && (!i.participant || nameKey(r.participant) === nameKey(i.participant)) && (!i.session || r.session === i.session) && (!i.activity || r.activity === i.activity) && (!i.kind || r.kind === i.kind)); }
     async gcEvidence(i) { const f = this.file('user', 'evidence'); await withFileLock(f + '.lock', LOCK, async () => write(f, (await read(f, this.clock())).filter(r => r.at >= i.before))); }
@@ -135,21 +135,12 @@ export class FileHostLedgerPort {
         }
         const latest = new Map();
         for (const x of b) {
-            const key = JSON.stringify([x.location, nameKey(x.participant)]);
+            const key = JSON.stringify([x.location, nameKey(x.participant), x.session]);
             const current = latest.get(key);
             if (current === undefined || ((x.updatedAt ?? 0) > (current.updatedAt ?? 0)))
                 latest.set(key, x);
         }
         const winners = [...latest.values()];
-        for (const x of b) {
-            const winner = latest.get(JSON.stringify([x.location, nameKey(x.participant)]));
-            if (winner === undefined || winner.session === x.session)
-                continue;
-            for (const scope of i.scopes ?? this.readable) {
-                const remover = new FileHostLedgerPort({ userPath: this.user, localPath: this.local, writableScope: scope, readableScopes: [scope], now: this.clock });
-                await remover.removePresence(x);
-            }
-        }
         const u = new FileHostLedgerPort({ userPath: this.user, localPath: this.local, writableScope: 'user', readableScopes: ['user'], now: this.clock });
         for (const x of winners) {
             const result = await u.ensurePresence(x);

package/dist/model.d.ts

@@ -13,6 +13,8 @@ export interface WakeRoute {
     address: Record<string, string>;
     updatedAt: number;
 }
+export interface ReceiverRoute extends WakeRoute {
+}
 export type SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | 'held' | 'capped' | 'throttled' | 'bell_quota' | 'behind' | 'io' | 'unavailable';
 export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reached' | 'conflict' | 'pending_peer';
 export interface SquareErrorFacts {
@@ -82,6 +84,7 @@ export interface SquareState {
     preamble: string[];
     warmup: string[];
     acts: StoredAct[];
+    routes?: ReceiverRoute[];
     runtime: SquareRuntimeState;
 }
 export interface ActivitiesOptions {

package/dist/model.js

@@ -40,7 +40,7 @@ export function findParticipantName(participants, name) {
     return participants.find((participant) => sameName(participant, name));
 }
 export function validateName(name) {
-    if (!name || !/^[\p{L}\p{N}_-]+(?:\/[\p{L}\p{N}_-]+)*$/u.test(name)) {
-        throw new SquareError('invalid_name', 'Invalid name: names must contain non-empty slash-separated segments using only Unicode letters, digits, hyphens, and underscores.');
+    if (!name || !/^(?:[[\p{L}\p{N}\p{M}_\x2D]--[\p{Variation_Selector}]]|\p{RGI_Emoji})+(?:\/(?:[[\p{L}\p{N}\p{M}_\x2D]--[\p{Variation_Selector}]]|\p{RGI_Emoji})+)*$/v.test(name)) {
+        throw new SquareError('invalid_name', 'Invalid name: names must contain non-empty slash-separated segments using Unicode letters, digits, marks, hyphens, underscores, or complete RGI emoji graphemes.');
     }
 }

package/dist/notifications.d.ts

@@ -2,9 +2,11 @@ import { planActNotifications, type WakeAdapter } from './delivery.js';
 import { type SquareState } from './model.js';
 import { matchesMentionTarget } from './runtime.js';
 import { type ActivityId } from './square-core.js';
+import type { WakeTransportPort } from './ports.js';
 export type { PlannedNotification } from './delivery.js';
 export { planActNotifications, matchesMentionTarget };
 export { notificationMessageId } from './delivery.js';
+export declare const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export declare function wakeGraceMs(env?: NodeJS.ProcessEnv): number;
 export declare function hasDeliveredNotification(squarePath: string, name: string, ref: number | ActivityId): Promise<boolean>;
 export declare function hasAttentionNotification(squarePath: string, name: string, ref: number | ActivityId, env?: NodeJS.ProcessEnv): Promise<boolean>;
@@ -16,7 +18,12 @@ interface ProcessNotificationOptions {
     env?: NodeJS.ProcessEnv;
     now?: () => number;
 }
+export declare function defaultWakeAdapters(): Promise<WakeAdapter[]>;
+export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv): Promise<WakeTransportPort>;
+export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number): WakeTransportPort;
 export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<import("./ports.js").DeliveryResult>;
+/** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares within one boundary budget. */
+export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedAdapters?: WakeAdapter[], deadline?: number): Promise<void>;
 export interface SweepPendingNotificationsOptions {
     env?: NodeJS.ProcessEnv;
     now?: number;