@astrosheep/square 0.3.10 → 0.3.12

package/dist/harness.js

@@ -1,8 +1,10 @@
 import fs from 'node:fs';
 import { doctorDeliveryHealth } from './delivery-health.js';
+import { wakeGraceMs } from './notifications.js';
 import { doctorClaudePlugin, installClaudePlugin, uninstallClaudePlugin, } from './harness-claude.js';
 import { doctorCodexPlugin, installCodexPlugin, uninstallCodexPlugin, } from './harness-codex.js';
-import { doctorHarnessLinks, installHarnessLinks, opencodeExtensionLink, piExtensionLink, skillLinks, uninstallHarnessLinks, verifyOpenCodeRuntime, } from './harness-links.js';
+import { doctorPiPackage, installPiPackage, uninstallPiPackage, } from './harness-pi.js';
+import { doctorHarnessLinks, installHarnessLinks, opencodeExtensionLink, skillLinks, uninstallHarnessLinks, verifyOpenCodeRuntime, } from './harness-links.js';
 function result(lines, notes = []) {
     return { lines, notes };
 }
@@ -28,13 +30,6 @@ function readableSquarePath(squarePath) {
     }
 }
 const TARGETS = [
-    {
-        name: 'skills',
-        capabilities: ['install', 'uninstall', 'doctor'],
-        install: ({ homeDir, force }) => result(installHarnessLinks(skillLinks(homeDir), force)),
-        uninstall: ({ homeDir }) => result(uninstallHarnessLinks(skillLinks(homeDir))),
-        doctor: ({ homeDir }) => result(doctorHarnessLinks(skillLinks(homeDir))),
-    },
     {
         name: 'claude',
         capabilities: ['install', 'uninstall', 'doctor'],
@@ -52,7 +47,7 @@ const TARGETS = [
         name: 'codex',
         capabilities: ['install', 'uninstall', 'doctor'],
         async install({ homeDir }) {
-            const installed = await installCodexPlugin(homeDir);
+            const installed = await installCodexPlugin(homeDir, undefined, process.env.CODEX_HOME);
             const lines = [
                 installed.configPath,
                 installed.marketplaceRoot,
@@ -62,10 +57,10 @@ const TARGETS = [
             return result(lines, installed.notes);
         },
         async uninstall({ homeDir }) {
-            const removed = await uninstallCodexPlugin(homeDir);
+            const removed = await uninstallCodexPlugin(homeDir, undefined, process.env.CODEX_HOME);
             return result(removed.paths, removed.notes);
         },
-        async doctor({ homeDir }) { return doctorHost('Codex', () => doctorCodexPlugin(homeDir)); },
+        async doctor({ homeDir }) { return doctorHost('Codex', () => doctorCodexPlugin(homeDir, undefined, process.env.CODEX_HOME)); },
     },
     {
         name: 'opencode',
@@ -77,15 +72,15 @@ const TARGETS = [
     {
         name: 'pi',
         capabilities: ['install', 'uninstall', 'doctor'],
-        install: ({ homeDir, force }) => result(installHarnessLinks([piExtensionLink(homeDir)], force)),
-        uninstall: ({ homeDir }) => result(uninstallHarnessLinks([piExtensionLink(homeDir)])),
-        doctor: ({ homeDir }) => result(doctorHarnessLinks([piExtensionLink(homeDir)])),
+        install: ({ homeDir }) => result(installPiPackage(homeDir)),
+        uninstall: ({ homeDir }) => result(uninstallPiPackage(homeDir)),
+        doctor: ({ homeDir }) => result(doctorPiPackage(homeDir)),
     },
     {
         name: 'delivery',
         capabilities: ['doctor'],
         doctor: ({ squarePath }) => result(readableSquarePath(squarePath)
-            ? doctorDeliveryHealth(squarePath)
+            ? doctorDeliveryHealth(squarePath, wakeGraceMs())
             : ['○ delivery health skipped (no readable square path)']),
     },
 ];

package/dist/help.js

@@ -11,14 +11,14 @@ const COMMANDS = [
         details: ['Options:', '  --depth <N>  Descend through at most N directory levels (default 4; 0 scans only the current directory).'],
     },
     {
-        names: ['join'], usage: '--as <name> join [--last N | --all]', usesSquare: true, group: 'participant',
+        names: ['join'], usage: '--as <name> join [--last N | --all] [--kick]', usesSquare: true, group: 'participant',
         summary: 'Step into the square and read its current context.',
         details: ['Options:', '  --last <N>  Show the last N public activities (default 10).', '  --all       Show the complete history.'],
     },
     {
-        names: ['express'], usage: '--as <name> express [-f|--force] [--no-wait] [--beside <name> | --bell] [--reply <act_N>] <activity | ->', usesSquare: true, group: 'participant',
+        names: ['express'], usage: '--as <name> express [-f|--force] [--no-wait] [--bell] [--reply <activity-id>] <activity | ->', usesSquare: true, group: 'participant',
         summary: 'Speak, gesture, or do both.',
-        details: ['Options:', '  -f, --force       Express without first catching unread activity.', '  --no-wait         If held or throttled, save a draft and return.', '  --beside <name>   Speak aside to one participant.', "  --bell            Call every participant's attention to this activity.", '  --reply <act_N>   Mark this activity as a reply to an earlier activity.'],
+        details: ['Reach:', '  @name             Address someone in the square. They hear the body; everyone else sees you walk over.', "  --bell            Call every participant's attention to this activity without a mention.", '', 'Options:', '  -f, --force       Express without first catching unread activity.', '  --no-wait         If held or throttled, save a draft and return.', '  --reply <activity-id>   Mark this activity as a reply to an earlier activity (for example act/12).'],
     },
     {
         names: ['catch'], usage: '--as <name> catch (--now | --idle <duration>) [--from <names>] [--mention [name]] [--replace]', usesSquare: true, group: 'participant',
@@ -39,10 +39,9 @@ const COMMANDS = [
     { names: ['claude-hook', 'codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
     {
         names: ['history'], usage: '[--as <name>] history [filters] [output]', usesSquare: true, group: 'participant',
-        summary: 'Read or search what happened 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 ids, participant names, and bodies.', '  --mention <name>                Match mentions.', '  --pending                       Match attention waiting for --as <name>.', '  --ids <ids> | --at <id>         Match stable activity ids.', '  -B, -A, -C <N>                 Set non-negative context around --at.', '  --after <id>                    Match activities after an id.', '', 'Results:', '  --limit <N> | --all             Bound the newest matches (default 10).', '  --order <asc|desc>              Set display order.', '', 'Output:', '  --full  --json  --format <fields>  --count'],
+        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 ids, participant names, and original bodies.', '  --mention <name>                Match mentions.', '  --pending                       Match attention waiting for --as <name>.', '  --ids <ids> | --at <id>         Match stable activity ids and show original bodies.', '  -B, -A, -C <N>                 Set non-negative context around --at.', '  --after <id>                    Match activities after an id.', '', 'Results:', '  --limit <N> | --all             Bound the newest matches (default 10).', '  --order <asc|desc>              Set display order.', '', 'Output:', '  --full  --json  --format <fields>  --count'],
     },
-    { names: ['warmup'], usage: 'warmup', usesSquare: true, group: 'host', summary: 'Print the complete embedded participant warmup.' },
     { 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.' },
     { names: ['hold'], usage: '--as <name> hold [reason | -]', usesSquare: true, group: 'participant', summary: 'Raise a hand and pause participant activity.' },
@@ -50,23 +49,22 @@ const COMMANDS = [
     {
         names: ['install'], usage: 'install (--all | <target>...) [-f]', group: 'maintenance',
         summary: 'Install Square support for one or more agent hosts.',
-        details: ['Targets:', '  skills, claude, codex, opencode, pi', '', 'Options:', '  --all       Install every supported target.', '  -f, --force Replace existing managed links.'],
+        details: ['Targets:', '  claude, codex, opencode, pi', '', 'Options:', '  --all       Install every supported target.', '  -f, --force Replace existing managed links.'],
     },
     {
         names: ['uninstall'], usage: 'uninstall (--all | <target>...)', group: 'maintenance',
         summary: 'Remove Square support from one or more agent hosts.',
-        details: ['Targets:', '  skills, claude, codex, opencode, pi', '', 'Options:', '  --all  Remove every supported target.'],
+        details: ['Targets:', '  claude, codex, opencode, pi', '', 'Options:', '  --all  Remove every supported target.'],
     },
     {
-        names: ['harness'], usage: 'harness doctor [skills|claude|codex|opencode|pi|delivery]', usesSquare: true, group: 'maintenance', hiddenFromIndex: true,
+        names: ['harness'], usage: 'harness doctor [claude|codex|opencode|pi|delivery]', usesSquare: true, group: 'maintenance', hiddenFromIndex: true,
         summary: 'Diagnose installed agent-host support.',
-        details: ['Targets:', '  skills, claude, codex, opencode, pi  Diagnose one installed adapter.', '  delivery                              Diagnose delivery for the selected square.'],
+        details: ['Targets:', '  claude, codex, opencode, pi  Diagnose one installed adapter.', '  delivery                      Diagnose delivery for the selected square.'],
     },
     { names: ['compact'], usage: 'compact [--keep N]', usesSquare: true, group: 'host', summary: 'Move older activity out of the working artifact while keeping the latest N.' },
     {
-        names: ['doctor'], usage: 'doctor [--fix]', usesSquare: true, group: 'maintenance',
-        summary: 'Diagnose artifact integrity.',
-        details: ['Options:', '  --fix              Repair recoverable artifact problems.'],
+        names: ['doctor'], usage: 'doctor', usesSquare: true, group: 'maintenance',
+        summary: 'Validate binary artifact integrity.',
     },
 ];
 function definitionFor(command) {
@@ -78,8 +76,8 @@ function isHelpFlag(value) {
 export function renderGlobalHelp() {
     const groups = [
         { key: 'participant', title: 'In the square:', order: ['join', 'express', 'catch', 'history', 'status', 'hold', 'resume', 'done'] },
-        { key: 'host', title: 'Prepare and manage:', order: ['build', 'list', 'participants', 'warmup', 'compact'] },
-        { key: 'maintenance', title: 'Setup and repair:', order: ['install', 'uninstall', 'doctor'] },
+        { key: 'host', title: 'Prepare and manage:', order: ['build', 'list', 'participants', 'compact'] },
+        { key: 'maintenance', title: 'Setup:', order: ['install', 'uninstall', 'doctor'] },
     ];
     const commandLines = groups.flatMap(({ key, title, order }) => [
         title,
@@ -90,7 +88,7 @@ export function renderGlobalHelp() {
         '',
     ]);
     return [
-        'Usage: square [--square-path <path>] [--as <name>] <command> [args...]',
+        'Usage: square [--location <path>] [--as <name>] <command> [args...]',
         '',
         ...commandLines,
         "Run 'square <command> --help' for command options.",
@@ -104,7 +102,7 @@ export function renderSubcommandHelp(command) {
     const aliases = definition.names.filter((name) => name !== command);
     const usage = definition.usage.replace('{command}', command);
     return [
-        `Usage: square ${definition.usesSquare ? '[--square-path <path>] ' : ''}${usage}`,
+        `Usage: square ${definition.usesSquare ? '[--location <path>] ' : ''}${usage}`,
         ...(aliases.length > 0 ? [`Aliases: ${aliases.join(', ')}`] : []),
         '',
         definition.summary,
@@ -121,7 +119,7 @@ export function helpRequest(rawArgs) {
     const args = [];
     for (let index = 0; index < rawArgs.length; index++) {
         const arg = rawArgs[index];
-        if (arg === '--square-path' || arg === '--as') {
+        if (arg === '--location' || arg === '--as') {
             const value = rawArgs[index + 1];
             if (value === undefined || value.startsWith('--'))
                 return undefined;

package/dist/index.js

@@ -1,19 +1,21 @@
 export { SquareError } from './model.js';
+export { extractMentions, formatActivityId, parseActivityId } from './square-core.js';
 export { loadSquare } from './artifact.js';
-export { extractMentions, countSays, joinedNames, doneNames, isCurrentlyJoined, publicActs, readCursor, } from './runtime.js';
+export { countSays, joinedNames, doneNames, isCurrentlyJoined, publicActs, readCursor, } from './runtime.js';
 import { loadSquare } from './artifact.js';
-import { hasDeliveredNotification as hasDeliveredNotificationImpl, waitForDeliveredNotification as waitForDeliveredNotificationImpl, } from './notifications.js';
+import { dispatchActNotifications, hasDeliveredNotification as hasDeliveredNotificationImpl, sweepPendingNotifications, waitForDeliveredNotification as waitForDeliveredNotificationImpl, } from './notifications.js';
 import { WATCH_STALE_MS, freshWatchLease, getReadState as getDocReadState, } from './runtime.js';
 import { resolveKnownName } from './decisions.js';
 import { execute } from './square-application.js';
+import { parseActivityId } from './square-core.js';
 export { WATCH_STALE_MS };
 function actRefIndex(ref) {
     if (typeof ref === 'number')
         return ref;
-    const match = ref.match(/^act_(\d+)$/);
-    if (!match)
+    const index = parseActivityId(ref);
+    if (index === undefined)
         throw new Error(`Invalid act ref: ${ref}`);
-    return Number(match[1]);
+    return index;
 }
 export function getReadState(squarePath, name) {
     const doc = loadSquare(squarePath);
@@ -52,6 +54,7 @@ export async function resume(squarePath, actor) {
     await execute(squarePath, { type: 'resume', actor, now: Date.now() });
 }
 export async function express(squarePath, name, body, opts = {}) {
+    await sweepPendingNotifications(squarePath);
     const committed = await execute(squarePath, {
         type: 'say',
         name,
@@ -60,6 +63,9 @@ export async function express(squarePath, name, body, opts = {}) {
         now: Date.now(),
         ...(opts.reply === undefined ? {} : { reply: actRefIndex(opts.reply) }),
     });
+    const sayAct = committed.acts.find((act) => act.kind === 'say');
+    if (sayAct !== undefined)
+        await dispatchActNotifications(squarePath, sayAct);
     if (committed.result.type !== 'sent')
         throw new Error(`Activity rejected: ${committed.result.type}`);
 }

package/dist/list.js

@@ -1,37 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { parseSquare } from './artifact.js';
+import { probeSquare } from './artifact.js';
 import { inSquareCount, publicActs } from './runtime.js';
 import { formatRelativeTime } from './time.js';
 const DEFAULT_LIST_DEPTH = 4;
 const LIST_SKIP_DIRS = new Set(['.git', 'node_modules', 'dist']);
-function frontmatterOf(text) {
-    const match = text.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
-    return match ? match[1] : null;
-}
-function candidateFrontmatter(filePath) {
-    let fd;
-    try {
-        fd = fs.openSync(filePath, 'r');
-        const buffer = Buffer.allocUnsafe(4096);
-        const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
-        const prefix = buffer.toString('utf8', 0, bytesRead);
-        if (!prefix.startsWith('---\n'))
-            return null;
-        const frontmatter = frontmatterOf(prefix);
-        return frontmatter ?? frontmatterOf(fs.readFileSync(filePath, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
-    }
-}
 function readSquareListItem(filePath, root) {
-    let text;
-    let doc;
     let stat;
     try {
         stat = fs.statSync(filePath);
@@ -39,27 +13,9 @@ function readSquareListItem(filePath, root) {
     catch {
         return null;
     }
-    const frontmatter = candidateFrontmatter(filePath);
-    if (!frontmatter)
-        return null;
-    if (!/^hard_cap:\s*(-1|\d+)\s*$/m.test(frontmatter))
+    const doc = probeSquare(filePath);
+    if (doc === undefined)
         return null;
-    if (!/^format_version:\s*3\s*$/m.test(frontmatter))
-        return null;
-    try {
-        text = fs.readFileSync(filePath, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    if (!text.includes('<!-- square:warmup -->') || !text.includes('<!-- square:activities -->'))
-        return null;
-    try {
-        doc = parseSquare(text);
-    }
-    catch {
-        return null;
-    }
     const relative = path.relative(root, filePath) || path.basename(filePath);
     return {
         path: relative,

package/dist/model.js

@@ -1,4 +1,8 @@
 // Shared model and constants for Square.
+export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-app-server', 'claude-native', 'pi-extension', 'paseo'];
+export function isWakeRouteKind(value) {
+    return typeof value === 'string' && WAKE_ROUTE_KINDS.includes(value);
+}
 export class SquareError extends Error {
     code;
     constructor(code, message) {
@@ -7,12 +11,6 @@ export class SquareError extends Error {
         this.name = 'SquareError';
     }
 }
-export const WARMUP_HEADING = '## Warmup';
-export const WARMUP_MARKER = '<!-- square:warmup -->';
-export const ACTIVITIES_HEADING = '## Activities';
-export const ACTIVITIES_MARKER = '<!-- square:activities -->';
-export const ACT_MARKER_PREFIX = '<!-- square:act';
-export const CURRENT_FORMAT_VERSION = 3;
 export function formatHardCap(hardCap) {
     return hardCap === null ? '-1' : String(hardCap);
 }

package/dist/notifications.js

@@ -1,13 +1,24 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
 import { loadSquare } from './artifact.js';
-import { isDeliveryDelivered, isPendingNotification, planActNotifications, } from './delivery.js';
-import { recordNotificationFailure } from './notification-failures.js';
+import { deriveDeliveryModel, isDeliveryDelivered, leaseOwnsNotification, planActNotifications, } from './delivery.js';
+import { sessionInbox } from './inbox.js';
 import { hasPresentedAttention } from './presented.js';
-import { SquareError } from './model.js';
+import { nameKey, SquareError } from './model.js';
 import { SLEEP_MS, matchesMentionTarget, resolveRosterName, rosterNames } from './runtime.js';
-import { defaultWakeSinks } from './paseo-delivery.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { PaseoAdapter } from './paseo-delivery.js';
+import { quoteShell } from './presentation.js';
+import { lookupParticipant } from './registry.js';
+import { isCurrentlyJoined } from './runtime.js';
+import { execute } from './square-application.js';
+import { nextWakeAttemptNumber, recordRecoveredUnknown, recordWakeAttempt, } from './wake-attempts.js';
+import { joinedRecipients, wakeEvidence, wakeIsEligible } from './wake-evidence.js';
+import { WakePort } from './wake-port.js';
+const NOTIFY_LEASE_MS = 5 * 60 * 1000;
 export { planActNotifications, matchesMentionTarget };
 function known(doc, name) {
     const value = resolveRosterName(doc, name);
@@ -16,20 +27,70 @@ function known(doc, name) {
     return value;
 }
 export { notificationMessageId } from './delivery.js';
-export function notificationDeliveryWaitMs() {
-    const value = Number.parseInt(process.env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? '5000', 10);
-    if (!Number.isFinite(value) || value <= 0)
+export function wakeGraceMs(env = process.env) {
+    const value = Number.parseInt(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? '5000', 10);
+    if (!Number.isFinite(value) || value <= 0) {
         throw new SquareError('invalid_args', 'Invalid SQUARE_NOTIFY_DELIVERY_WAIT_MS: expected a positive integer.');
+    }
     return value;
 }
+function catchCommand(squarePath, recipient) {
+    return `square --as ${quoteShell(recipient)} --location ${quoteShell(squarePath)} catch --now`;
+}
+function renderWakePayload(request) {
+    const display = request.squarePath.startsWith(homedir())
+        ? `~${request.squarePath.slice(homedir().length)}`
+        : request.squarePath;
+    return [
+        '<system-reminder source="square">',
+        `${request.route === 'bell' ? 'Bell' : 'Mention'} from @${request.actor} in \`${display}\``,
+        'The native adapter will present it at the next boundary. If no native wake is available, pull from the square yourself.',
+        `\`${catchCommand(request.squarePath, request.recipient)}\``,
+        '</system-reminder>',
+    ].join('\n');
+}
+async function waitForCatch(route, request, body) {
+    const binding = lookupParticipant(request.squarePath, request.recipient)
+        .find((item) => item.ownerId === route.ownerId);
+    const activeCatch = binding && sessionInbox(binding.sessionId)
+        .find((item) => item.name === request.recipient)?.catchLease;
+    if (!activeCatch || !leaseOwnsNotification(activeCatch, {
+        actor: request.actor,
+        body,
+        route: request.route,
+    }))
+        return false;
+    const deadline = Date.now() + 180_000;
+    while (Date.now() < deadline) {
+        const doc = loadSquare(request.squarePath);
+        if (isDeliveryDelivered(doc, request.recipient, request.actIndex))
+            return true;
+        const currentBinding = lookupParticipant(request.squarePath, request.recipient)
+            .find((item) => item.ownerId === route.ownerId);
+        const lease = currentBinding && sessionInbox(currentBinding.sessionId)
+            .find((item) => item.name === request.recipient)?.catchLease;
+        if (!lease || lease.expiresAt <= Date.now())
+            return false;
+        await sleep(Math.min(250, lease.expiresAt - Date.now()));
+    }
+    return false;
+}
+function notificationIndex(ref) {
+    if (typeof ref === 'number')
+        return ref;
+    const index = parseActivityId(ref);
+    if (index === undefined)
+        throw new Error(`Invalid act ref: ${ref}`);
+    return index;
+}
 export function hasDeliveredNotification(squarePath, name, ref) {
     const doc = loadSquare(squarePath);
-    return isDeliveryDelivered(doc, known(doc, name), typeof ref === 'number' ? ref : Number(ref.slice(4)));
+    return isDeliveryDelivered(doc, known(doc, name), notificationIndex(ref));
 }
 export function hasAttentionNotification(squarePath, name, ref, env = process.env) {
     const doc = loadSquare(squarePath);
     const recipient = known(doc, name);
-    const index = typeof ref === 'number' ? ref : Number(ref.slice(4));
+    const index = notificationIndex(ref);
     return isDeliveryDelivered(doc, recipient, index) || hasPresentedAttention(squarePath, recipient, index, env);
 }
 export async function waitForDeliveredNotification(squarePath, name, ref, opts = {}) {
@@ -41,31 +102,128 @@ export async function waitForDeliveredNotification(squarePath, name, ref, opts =
     }
     return false;
 }
+function notifyLeaseKey(recipient, actIndex) {
+    return JSON.stringify([formatActivityId(actIndex), nameKey(recipient)]);
+}
+async function claimNotifyLease(squarePath, recipient, actIndex) {
+    const at = Date.now();
+    const committed = await execute(squarePath, {
+        type: 'claim-notify',
+        key: notifyLeaseKey(recipient, actIndex),
+        leaseId: randomUUID(),
+        at,
+        expiresAt: at + NOTIFY_LEASE_MS,
+    });
+    return committed.result;
+}
+async function transitionNotifyLease(squarePath, recipient, actIndex, leaseId, phase, routeKind, attemptN) {
+    const at = Date.now();
+    const committed = await execute(squarePath, {
+        type: 'transition-notify',
+        key: notifyLeaseKey(recipient, actIndex),
+        leaseId,
+        expiresAt: at + NOTIFY_LEASE_MS,
+        phase,
+        ...(routeKind === undefined ? {} : { routeKind }),
+        ...(attemptN === undefined ? {} : { attemptN }),
+    });
+    return committed.result.updated;
+}
+function releaseNotifyLease(squarePath, recipient, actIndex, leaseId) {
+    return execute(squarePath, {
+        type: 'release-notify',
+        key: notifyLeaseKey(recipient, actIndex),
+        leaseId,
+    });
+}
+async function processNotification(squarePath, notification, opts) {
+    const env = opts.env ?? process.env;
+    const now = opts.now ?? Date.now;
+    const attention = {
+        squarePath,
+        actIndex: notification.item.index,
+        recipient: notification.recipient,
+    };
+    const initialAt = now();
+    if (!wakeIsEligible(wakeEvidence(squarePath, notification.recipient, notification.item.index, initialAt, env)))
+        return;
+    const claim = await claimNotifyLease(squarePath, notification.recipient, notification.item.index);
+    if (claim.type === 'busy')
+        return;
+    if (claim.type === 'ambiguous') {
+        const recovered = recordRecoveredUnknown(attention, claim.lease, env);
+        if (recovered !== undefined) {
+            await releaseNotifyLease(squarePath, notification.recipient, notification.item.index, claim.lease.leaseId);
+        }
+        return;
+    }
+    const { leaseId } = claim;
+    let releaseLease = true;
+    try {
+        const dispatchAt = now();
+        const evidence = wakeEvidence(squarePath, notification.recipient, notification.item.index, dispatchAt, env);
+        if (!wakeIsEligible(evidence))
+            return;
+        const port = new WakePort(opts.adapters ?? [new PaseoAdapter()]);
+        const request = {
+            squarePath,
+            actIndex: notification.item.index,
+            recipient: notification.recipient,
+            actor: notification.item.actor,
+            route: notification.route,
+        };
+        await port.dispatch(evidence.attemptableRoutes, renderWakePayload(request), {
+            nextAttemptN: () => nextWakeAttemptNumber(attention, { env, now: now() }),
+            beforeSend: async (route, attemptN) => {
+                if (await waitForCatch(route, request, notification.item.body))
+                    return false;
+                const currentAt = now();
+                const latest = loadSquare(squarePath);
+                if (!isCurrentlyJoined(latest.acts, notification.recipient))
+                    return false;
+                const current = wakeEvidence(squarePath, notification.recipient, notification.item.index, currentAt, env);
+                if (!wakeIsEligible(current))
+                    return false;
+                if (!current.attemptableRoutes.some((candidate) => candidate.ownerId === route.ownerId && candidate.kind === route.kind && candidate.sessionId === route.sessionId))
+                    return false;
+                const dispatching = await transitionNotifyLease(squarePath, notification.recipient, notification.item.index, leaseId, 'dispatching', route.kind, attemptN);
+                if (dispatching)
+                    releaseLease = false;
+                return dispatching;
+            },
+            record: async (route, attemptN, outcome) => {
+                if (outcome.outcome === 'failed') {
+                    await transitionNotifyLease(squarePath, notification.recipient, notification.item.index, leaseId, 'claimed');
+                    releaseLease = true;
+                }
+                recordWakeAttempt({
+                    attention,
+                    routeKind: route.kind,
+                    outcome: outcome.outcome,
+                    attemptN,
+                    at: now(),
+                    ...('signature' in outcome ? { signature: outcome.signature } : {}),
+                    ...('message' in outcome ? { message: outcome.message } : {}),
+                    ...('diagnostic' in outcome && outcome.diagnostic !== undefined ? { diagnostic: outcome.diagnostic } : {}),
+                }, env);
+                if (outcome.outcome !== 'failed')
+                    releaseLease = true;
+            },
+        });
+    }
+    finally {
+        if (releaseLease) {
+            await releaseNotifyLease(squarePath, notification.recipient, notification.item.index, leaseId);
+        }
+    }
+}
 export async function processActNotificationsOnce(squarePath, actIndex, opts = {}) {
     const doc = loadSquare(squarePath);
     const item = doc.acts.find((candidate) => candidate.index === actIndex);
     if (item === undefined)
         return;
-    const notifications = planActNotifications(doc, item).filter(isPendingNotification);
-    for (const notification of notifications) {
-        if (hasAttentionNotification(squarePath, notification.recipient, notification.item.index))
-            continue;
-        for (const sink of opts.sinks ?? defaultWakeSinks()) {
-            try {
-                await sink.dispatch(notification, { squarePath });
-            }
-            catch (error) {
-                recordNotificationFailure(squarePath, {
-                    actIndex: notification.item.index,
-                    recipient: notification.recipient,
-                    route: notification.route,
-                    sink: sink.name,
-                    message: error instanceof Error ? error.message : String(error),
-                    ...(error instanceof Error && 'diagnostic' in error ? { diagnostic: error.diagnostic } : {}),
-                });
-            }
-        }
-    }
+    const notifications = planActNotifications(doc, item);
+    await Promise.all(notifications.map((notification) => processNotification(squarePath, notification, opts)));
 }
 function launchWorker(workerPath, args) {
     const child = spawn(process.execPath, [workerPath, ...args], { detached: true, stdio: 'ignore', env: process.env });
@@ -73,10 +231,37 @@ function launchWorker(workerPath, args) {
 }
 /** Start one detached worker only when this act contains directed attention. */
 export async function dispatchActNotifications(squarePath, item, opts = {}) {
-    if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
+    const env = opts.env ?? process.env;
+    if (env.SQUARE_DISABLE_PASEO_WAKE === '1')
         return;
     const doc = loadSquare(squarePath);
-    if (!planActNotifications(doc, item).some(isPendingNotification))
+    if (planActNotifications(doc, item).length === 0)
         return;
-    (opts.launchWorker ?? launchWorker)(fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url)), ['--square-path', squarePath, '--act-index', String(item.index)]);
+    (opts.launchWorker ?? launchWorker)(fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url)), ['--location', squarePath, '--act-index', String(item.index)]);
+}
+/** Reconsider old pending attention at a bounded action boundary using the existing worker. */
+export function sweepPendingNotifications(squarePath, opts = {}) {
+    const env = opts.env ?? process.env;
+    if (env.SQUARE_DISABLE_PASEO_WAKE === '1')
+        return [];
+    const now = opts.now ?? Date.now();
+    const limit = opts.limit ?? 8;
+    const doc = loadSquare(squarePath);
+    const model = deriveDeliveryModel(doc);
+    const indexes = new Set();
+    for (const recipient of joinedRecipients(doc)) {
+        for (const note of model.pendingFor(recipient)) {
+            if (now - note.item.at <= wakeGraceMs(env))
+                continue;
+            if (!wakeIsEligible(wakeEvidence(squarePath, recipient, note.item.index, now, env)))
+                continue;
+            indexes.add(note.item.index);
+        }
+    }
+    const selected = [...indexes].sort((a, b) => a - b).slice(0, Math.max(0, limit));
+    const workerPath = fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url));
+    for (const actIndex of selected) {
+        (opts.launchWorker ?? launchWorker)(workerPath, ['--location', squarePath, '--act-index', String(actIndex)]);
+    }
+    return selected;
 }