@astrosheep/square 0.3.9 → 0.3.11

package/dist/notifications.js

@@ -1,13 +1,23 @@
 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, isPendingNotification, 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 { 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,12 +26,55 @@ 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' : request.route === 'beside' ? 'Beside' : '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,
+        recipient: request.recipient,
+    }))
+        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;
+}
 export function hasDeliveredNotification(squarePath, name, ref) {
     const doc = loadSquare(squarePath);
     return isDeliveryDelivered(doc, known(doc, name), typeof ref === 'number' ? ref : Number(ref.slice(4)));
@@ -41,31 +94,128 @@ export async function waitForDeliveredNotification(squarePath, name, ref, opts =
     }
     return false;
 }
+function notifyLeaseKey(recipient, actIndex) {
+    return JSON.stringify([`act_${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 } : {}),
-                });
-            }
-        }
-    }
+    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 +223,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))
         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;
 }

package/dist/paseo-connection.js

@@ -0,0 +1,135 @@
+import fs from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { DaemonClient } from '@getpaseo/client/internal/daemon-client';
+import WebSocket from 'ws';
+const DEFAULT_HOST = 'localhost:6767';
+const DEFAULT_CONNECT_TIMEOUT_MS = 3_000;
+function paseoHome(env) {
+    return env.PASEO_HOME?.trim() || path.join(homedir(), '.paseo');
+}
+function expandHome(value) {
+    return value === '~' ? homedir() : value.startsWith('~/') ? path.join(homedir(), value.slice(2)) : value;
+}
+function normalizeHost(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return undefined;
+    const value = raw.trim();
+    if (value.startsWith('unix://') || value.startsWith('pipe://') || value.startsWith('tcp://'))
+        return value;
+    if (value.startsWith('\\\\.\\pipe\\'))
+        return `pipe://${value}`;
+    if (value.startsWith('/') || value.startsWith('~/'))
+        return `unix://${expandHome(value)}`;
+    if (/^\d+$/.test(value))
+        return `127.0.0.1:${value}`;
+    return value.includes(':') ? value : undefined;
+}
+function configuredHost(env) {
+    try {
+        const config = JSON.parse(fs.readFileSync(path.join(paseoHome(env), 'config.json'), 'utf8'));
+        return normalizeHost(config.daemon?.listen ?? config.listen);
+    }
+    catch {
+        return undefined;
+    }
+}
+function pidHost(env) {
+    try {
+        const pid = JSON.parse(fs.readFileSync(path.join(paseoHome(env), 'paseo.pid'), 'utf8'));
+        return normalizeHost(pid.listen ?? pid.sockPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isIpc(host) {
+    return host !== undefined && (host.startsWith('unix://') || host.startsWith('pipe://'));
+}
+/** Match the host precedence used by the Paseo CLI for local daemon connections. */
+export function paseoDaemonHosts(env = process.env) {
+    const explicit = normalizeHost(env.PASEO_HOST);
+    if (explicit !== undefined)
+        return [explicit];
+    const candidates = [];
+    const listen = normalizeHost(env.PASEO_LISTEN);
+    const pid = pidHost(env);
+    const configured = configuredHost(env);
+    if (isIpc(listen))
+        candidates.push(listen);
+    if (isIpc(pid))
+        candidates.push(pid);
+    if (isIpc(configured))
+        candidates.push(configured);
+    if (configured !== undefined && !isIpc(configured) && configured !== '127.0.0.1:6767')
+        candidates.push(configured);
+    candidates.push(DEFAULT_HOST);
+    return [...new Set(candidates)];
+}
+function uriPassword(uri) {
+    const value = uri.searchParams.get('password');
+    return value === null || value === '' ? undefined : value;
+}
+export function resolvePaseoDaemonTarget(host, env = process.env) {
+    const passwordFromEnv = env.PASEO_PASSWORD?.trim() || undefined;
+    if (host.startsWith('unix://') || host.startsWith('pipe://')) {
+        const prefix = host.startsWith('unix://') ? 'unix://' : 'pipe://';
+        const socketPath = expandHome(host.slice(prefix.length).trim());
+        if (socketPath === '')
+            throw new Error('Invalid Paseo IPC target: missing socket path.');
+        return {
+            type: 'ipc',
+            url: host.startsWith('unix://') ? `ws+unix://${socketPath}:/ws` : 'ws://localhost/ws',
+            socketPath,
+            ...(passwordFromEnv === undefined ? {} : { password: passwordFromEnv }),
+        };
+    }
+    if (host.startsWith('tcp://')) {
+        const uri = new URL(host);
+        const hostname = uri.hostname.replace(/^\[|\]$/g, '');
+        const endpoint = `${hostname.includes(':') ? `[${hostname}]` : hostname}:${uri.port || '6767'}`;
+        const secure = uri.searchParams.get('ssl') === 'true';
+        const password = uriPassword(uri) ?? passwordFromEnv;
+        return {
+            type: 'tcp',
+            url: `${secure ? 'wss' : 'ws'}://${endpoint}/ws`,
+            ...(password === undefined ? {} : { password }),
+        };
+    }
+    return {
+        type: 'tcp',
+        url: `ws://${host.replace(/\/$/, '')}/ws`,
+        ...(passwordFromEnv === undefined ? {} : { password: passwordFromEnv }),
+    };
+}
+function webSocketFactory(target) {
+    return (url, options) => new WebSocket(url, options?.protocols, {
+        headers: options?.headers,
+        ...(target.type === 'ipc' ? { socketPath: target.socketPath } : {}),
+    });
+}
+export async function connectPaseoDaemon(env = process.env, connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+    let lastError;
+    for (const host of paseoDaemonHosts(env)) {
+        const target = resolvePaseoDaemonTarget(host, env);
+        const client = new DaemonClient({
+            url: target.url,
+            clientId: `square-${process.pid}-${Date.now()}`,
+            clientType: 'cli',
+            appVersion: 'square',
+            password: target.password,
+            connectTimeoutMs,
+            webSocketFactory: webSocketFactory(target),
+            reconnect: { enabled: false },
+        });
+        try {
+            await client.connect();
+            return client;
+        }
+        catch (error) {
+            lastError = error;
+            await client.close().catch(() => { });
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error('Unable to connect to the Paseo daemon.');
+}

package/dist/paseo-delivery.js

@@ -1,160 +1,89 @@
-import { homedir } from 'node:os';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { loadSquare } from './artifact.js';
-import { isDeliveryDelivered, leaseOwnsNotification, } from './delivery.js';
-import { sessionInbox } from './inbox.js';
-import { hasPresentedForOwner, presentOnce } from './presented.js';
-import { lookupParticipant } from './registry.js';
-import { quoteShell } from './presentation.js';
-import { isCurrentlyJoined, resolveRosterName } from './runtime.js';
-import { discoverPaseoAgents, waitForPaseoWakeBoundary, } from './paseo-state.js';
-import { sendPaseoWake } from './wake-sink.js';
-export class PaseoWakeError extends Error {
-    diagnostic;
-    constructor(message, diagnostic) {
-        super(message);
-        this.diagnostic = diagnostic;
-        this.name = 'PaseoWakeError';
-    }
-}
+import { paseoDaemonHosts, resolvePaseoDaemonTarget } from './paseo-connection.js';
+import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
+import { PaseoWakeSendError, sendPaseoWake } from './wake-sink.js';
 function endpoint() {
-    return process.env.SQUARE_PASEO_WS_URL ?? process.env.PASEO_LISTEN ?? '127.0.0.1:6767';
+    try {
+        return resolvePaseoDaemonTarget(paseoDaemonHosts()[0]).url;
+    }
+    catch {
+        return 'unresolved';
+    }
 }
-function diagnostic(phase, ownership, code) {
+function diagnostic(phase, address, code) {
     return {
         phase,
         code,
-        command: phase === 'discovery' ? 'paseo ls --json' : 'paseo send <agent-id> --prompt <prompt> --no-wait',
+        command: phase === 'discovery' ? 'paseo ls --global --json' : 'paseo send <agent-id> --prompt <prompt> --no-wait --json',
         endpoint: endpoint(),
-        paseoAgentIds: ownership.map((item) => item.agentId),
-        ownerIds: [...new Set(ownership.map((item) => item.ownerId))],
+        paseoAgentIds: [address.agentId].filter(Boolean),
         passwordPresent: Boolean(process.env.PASEO_PASSWORD),
     };
 }
-function native(binding) {
-    return ['claude-code', 'codex', 'opencode', 'pi'].includes(binding.channel);
-}
-function ownershipSnapshot(bindings) {
-    const out = new Map();
-    for (const binding of bindings) {
-        if (!binding.paseoAgentId)
-            continue;
-        const owner = bindings.filter((item) => item.ownerId === binding.ownerId);
-        out.set(`${binding.ownerId}\0${binding.paseoAgentId}`, {
-            agentId: binding.paseoAgentId,
-            ownerId: binding.ownerId,
-            sessionId: owner.find(native)?.sessionId ?? binding.sessionId,
-            nativeGuarantee: owner.some(native),
-        });
-    }
-    return [...out.values()];
-}
-function selectActiveAgents(ownership, agents) {
-    const ids = new Set(ownership.map((item) => item.agentId));
-    return agents.filter((agent) => ids.has(agent.id) && (agent.status === 'idle' || agent.status === 'running'));
-}
-function catchCommand(squarePath, recipient) {
-    return `square --as ${quoteShell(recipient)} --square-path ${quoteShell(squarePath)} catch --now`;
+function discoveryRetryable(message) {
+    if (/password|auth|unauthori[sz]ed/i.test(message))
+        return false;
+    return /DAEMON_NOT_RUNNING|ECONNREFUSED|ENOENT|not found.*executable|ETIMEDOUT|timed out|timeout/i.test(message);
 }
-function prompt(notification, squarePath, nativeWake) {
-    const display = squarePath.startsWith(homedir()) ? `~${squarePath.slice(homedir().length)}` : squarePath;
-    const body = notification.item.body.length > 200 ? `${notification.item.body.slice(0, 197)}...` : notification.item.body;
-    return [
-        '<system-reminder source="square">',
-        `${notification.route === 'bell' ? 'Bell' : notification.route === 'beside' ? 'Beside' : 'Mention'} from @${notification.item.actor} in \`${display}\``,
-        nativeWake ? 'The native adapter will present it at the next boundary.' : `> ${body.replace(/\n/g, '\n> ')}`,
-        `\`${catchCommand(squarePath, notification.recipient)}\``,
-        '</system-reminder>',
-    ].join('\n');
-}
-async function waitForCatch(squarePath, recipient, actIndex, ownerId) {
-    const deadline = Date.now() + 180_000;
-    while (Date.now() < deadline) {
-        const doc = loadSquare(squarePath);
-        if (isDeliveryDelivered(doc, recipient, actIndex))
-            return true;
-        const binding = lookupParticipant(squarePath, recipient).find((item) => item.ownerId === ownerId);
-        const lease = binding && sessionInbox(binding.sessionId).find((item) => item.name === recipient)?.catchLease;
-        if (!lease || lease.expiresAt <= Date.now())
-            return false;
-        await sleep(Math.min(250, lease.expiresAt - Date.now()));
+export class PaseoAdapter {
+    opts;
+    kind = 'paseo';
+    constructor(opts = {}) {
+        this.opts = opts;
     }
-    return false;
-}
-function send(request, ownership) {
-    try {
-        sendPaseoWake(request);
-    }
-    catch (error) {
-        throw new PaseoWakeError(error instanceof Error ? error.message : String(error), diagnostic('send', ownership, 'failed'));
-    }
-}
-export async function dispatchPaseoNotification(notification, ctx) {
-    const initial = loadSquare(ctx.squarePath);
-    const recipient = resolveRosterName(initial, notification.recipient);
-    if (!recipient || !isCurrentlyJoined(initial.acts, recipient))
-        return;
-    const ownership = ownershipSnapshot(lookupParticipant(ctx.squarePath, recipient));
-    if (ownership.length === 0)
-        return;
-    const discovery = discoverPaseoAgents();
-    if (discovery.error && discovery.agents.length === 0) {
-        throw new PaseoWakeError(`Paseo unavailable: ${discovery.error}`, diagnostic('discovery', ownership, 'unavailable'));
-    }
-    const active = selectActiveAgents(ownership, discovery.agents);
-    if (active.length === 0) {
-        throw new PaseoWakeError('No registered Paseo agent is idle or running.', diagnostic('selection', ownership, 'not_active'));
-    }
-    let boundaryTimedOut = false;
-    for (const agent of active) {
-        const owner = ownership.find((item) => item.agentId === agent.id);
-        if (!owner || hasPresentedForOwner(owner.ownerId, ctx.squarePath, recipient, notification.item.index))
-            continue;
-        if (!(await waitForPaseoWakeBoundary(agent))) {
-            boundaryTimedOut = true;
-            continue;
+    async dispatch(address, payload, beforeSend) {
+        const agentId = address.agentId?.trim();
+        if (!agentId) {
+            return {
+                outcome: 'failed',
+                signature: 'invalid_address',
+                message: 'Paseo route has no agent id.',
+                diagnostic: diagnostic('selection', address, 'invalid_address'),
+            };
         }
-        const latest = loadSquare(ctx.squarePath);
-        if (!isCurrentlyJoined(latest.acts, recipient) || isDeliveryDelivered(latest, recipient, notification.item.index))
-            return;
-        const current = lookupParticipant(ctx.squarePath, recipient).find((item) => item.ownerId === owner.ownerId && item.paseoAgentId === owner.agentId);
-        if (!current)
-            continue;
-        const activeCatch = sessionInbox(current.sessionId).find((item) => item.name === recipient)?.catchLease;
-        if (activeCatch &&
-            leaseOwnsNotification(activeCatch, {
-                actor: notification.item.actor,
-                body: notification.item.body,
-                route: notification.route,
-                recipient,
-            }) &&
-            (await waitForCatch(ctx.squarePath, recipient, notification.item.index, owner.ownerId))) {
-            return;
+        const discovery = (this.opts.discover ?? discoverPaseoAgents)();
+        if (discovery.error && discovery.agents.length === 0) {
+            return {
+                outcome: 'failed',
+                signature: discoveryRetryable(discovery.error) ? 'discovery_transient' : 'discovery_rejected',
+                message: `Paseo unavailable: ${discovery.error}`,
+                diagnostic: diagnostic('discovery', address, 'unavailable'),
+            };
         }
-        const nativeWake = owner.nativeGuarantee;
-        const request = {
-            agentId: agent.id,
-            prompt: prompt({ ...notification, recipient }, ctx.squarePath, nativeWake),
-        };
-        if (nativeWake) {
-            send(request, ownership);
-            return;
+        const agent = discovery.agents.find((candidate) => candidate.id === agentId);
+        if (agent === undefined || (agent.status !== 'idle' && agent.status !== 'running')) {
+            return {
+                outcome: 'failed',
+                signature: agent === undefined ? 'address_not_found' : 'agent_not_active',
+                message: agent === undefined ? 'The registered Paseo agent was not found.' : 'The registered Paseo agent is not idle or running.',
+                diagnostic: diagnostic('selection', address, agent === undefined ? 'not_found' : 'not_active'),
+            };
+        }
+        if (!(await (this.opts.waitForBoundary ?? waitForPaseoWakeBoundary)(agent))) {
+            return {
+                outcome: 'failed',
+                signature: 'boundary_unavailable',
+                message: 'Paseo did not reach the current tool boundary before the wake timeout.',
+                diagnostic: diagnostic('boundary', address, 'unavailable'),
+            };
+        }
+        if (!(await beforeSend()))
+            return { outcome: 'cancelled' };
+        try {
+            (this.opts.sendWake ?? sendPaseoWake)({ agentId, prompt: payload });
+            return { outcome: 'accepted' };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const kind = error instanceof PaseoWakeSendError ? error.kind : 'unknown';
+            const details = { ...diagnostic('send', address, 'failed'), outcome: kind };
+            if (kind === 'unknown')
+                return { outcome: 'unknown', signature: 'send_unknown', message, diagnostic: details };
+            return {
+                outcome: 'failed',
+                signature: kind === 'transient' ? 'send_pre_accept_transient' : 'send_pre_accept_rejected',
+                message,
+                diagnostic: details,
+            };
         }
-        presentOnce(current.sessionId, (id) => sessionInbox(id)
-            .map((item) => ({ ...item, notifications: item.notifications.filter((note) => note.actIndex === notification.item.index) }))
-            .filter((item) => item.notifications.length > 0), () => {
-            send(request, ownership);
-            return true;
-        });
-        return;
-    }
-    if (boundaryTimedOut) {
-        throw new PaseoWakeError('Paseo did not reach the current tool boundary before the wake timeout.', diagnostic('boundary', ownership, 'timeout'));
     }
 }
-export function paseoWakeSink() {
-    return { name: 'paseo', dispatch: dispatchPaseoNotification };
-}
-export function defaultWakeSinks() {
-    return process.env.SQUARE_DISABLE_PASEO_WAKE === '1' ? [] : [paseoWakeSink()];
-}

package/dist/paseo-state.js

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { waitForPaseoToolBoundary } from './paseo-timeline.js';
 export function discoverPaseoAgents(timeoutMs = 5000) {
     try {
-        const raw = execFileSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['ls', '--json'], {
+        const raw = execFileSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['ls', '--global', '--json'], {
             encoding: 'utf8',
             timeout: timeoutMs,
             stdio: ['ignore', 'pipe', 'pipe'],