@astrosheep/square 0.3.2

package/dist/stream.js

@@ -0,0 +1,149 @@
+// stream.ts — live activity feed
+import fs from 'node:fs';
+import path from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { loadSquare } from './artifact.js';
+import { planActNotifications } from './notifications.js';
+import { sameName } from './model.js';
+import { indexedDelta } from './activity-feed.js';
+import { SLEEP_MS, actStableIndex, inSquareCount, latestIndexedActIndex, nowMs, rosterNames, sayNumberFor } from './runtime.js';
+import { quoteShell } from './presentation.js';
+import { enableRawMode, disableRawMode, enterAlternateScreen, leaveAlternateScreen, clearScreen, hideCursor, showCursor, renderStreamHeader, renderStreamEvent, renderWaiting, cursorUp, clearLine, } from './terminal.js';
+const INITIAL_DUMP = 20;
+export function streamNotificationFor(doc, item, recipient) {
+    return planActNotifications(doc, item).find((notification) => sameName(notification.recipient, recipient));
+}
+export function matchesStreamRecipient(doc, item, recipient) {
+    return streamNotificationFor(doc, item, recipient) !== undefined;
+}
+function renderDump(squarePath, doc, events, now) {
+    const relevant = events.filter((item) => item.act.kind !== 'read');
+    const active = inSquareCount(doc);
+    if (relevant.length === 0)
+        return `${renderStreamHeader(squarePath, rosterNames(doc).length, active)}\n\n  (no activity yet)\n`;
+    const header = renderStreamHeader(squarePath, rosterNames(doc).length, active);
+    const body = relevant.map((item) => renderStreamEvent(item.act, now, item.act.kind === 'say' ? sayNumberFor(doc.acts, item.act) : undefined)).join('');
+    return `${header}\n${body}`;
+}
+export async function cmdStreamNdjson(squarePath, forName) {
+    if (!fs.existsSync(squarePath)) {
+        process.stderr.write(`square not found: ${squarePath}\n`);
+        process.exit(2);
+    }
+    let doc = loadSquare(squarePath);
+    let cursor = -1;
+    const emit = (events) => {
+        for (const { act, index } of events) {
+            const item = { act, index };
+            const notification = forName ? streamNotificationFor(doc, item, forName) : undefined;
+            if (forName && !notification)
+                continue;
+            process.stdout.write(`${JSON.stringify({
+                seq: index,
+                square: squarePath,
+                ...act,
+                ...(notification ? { via: notification.via } : {}),
+            })}\n`);
+        }
+    };
+    const backlog = indexedDelta(doc.acts, cursor);
+    emit(backlog);
+    cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
+    while (true) {
+        await sleep(SLEEP_MS);
+        try {
+            doc = loadSquare(squarePath);
+        }
+        catch {
+            // Transient read failure (e.g. concurrent writer mid-rename) — retry next poll.
+            continue;
+        }
+        const delta = indexedDelta(doc.acts, cursor);
+        if (delta.length === 0)
+            continue;
+        emit(delta);
+        cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
+    }
+}
+async function readKey() {
+    return new Promise((resolve) => {
+        const finish = (value) => {
+            clearTimeout(timer);
+            process.stdin.removeListener('data', onData);
+            resolve(value);
+        };
+        const onData = (chunk) => finish(chunk.toString());
+        const timer = setTimeout(() => finish(null), 100);
+        timer.unref();
+        process.stdin.once('data', onData);
+    });
+}
+export async function cmdStream(squarePath) {
+    if (!fs.existsSync(squarePath)) {
+        process.stderr.write(`square not found: ${squarePath}\n`);
+        process.exit(2);
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write('✕ interactive stream requires a TTY\n');
+        process.stderr.write(`» square --square-path ${quoteShell(path.resolve(squarePath))} stream --ndjson\n`);
+        process.exit(2);
+    }
+    let doc = loadSquare(squarePath);
+    let cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
+    let stoppedBy;
+    const stop = (signal) => {
+        stoppedBy = signal;
+    };
+    const onSigint = () => stop('SIGINT');
+    const onSigterm = () => stop('SIGTERM');
+    process.once('SIGINT', onSigint);
+    process.once('SIGTERM', onSigterm);
+    enterAlternateScreen();
+    enableRawMode();
+    hideCursor();
+    clearScreen();
+    try {
+        const allIndexed = doc.acts.map((act) => ({ act, index: actStableIndex(act) }));
+        const initial = allIndexed.filter((item) => item.act.kind !== 'read').slice(-INITIAL_DUMP);
+        cursor = Math.max(cursor, latestIndexedActIndex(initial));
+        process.stdout.write(renderDump(squarePath, doc, initial, nowMs()));
+        process.stdout.write(renderWaiting());
+        while (stoppedBy === undefined) {
+            const key = await readKey();
+            if (key === 'q' || key === '\x1b' || key === '\x03')
+                break;
+            try {
+                doc = loadSquare(squarePath);
+            }
+            catch {
+                await sleep(SLEEP_MS);
+                continue;
+            }
+            const delta = indexedDelta(doc.acts, cursor);
+            if (delta.length === 0) {
+                await sleep(SLEEP_MS);
+                continue;
+            }
+            cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
+            cursorUp(1);
+            clearLine();
+            const fresh = nowMs();
+            for (const item of delta) {
+                if (item.act.kind !== 'read') {
+                    process.stdout.write(renderStreamEvent(item.act, fresh, item.act.kind === 'say' ? sayNumberFor(doc.acts, item.act) : undefined));
+                }
+            }
+            process.stdout.write(renderWaiting());
+        }
+    }
+    finally {
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
+        disableRawMode();
+        showCursor();
+        leaveAlternateScreen();
+        showCursor();
+    }
+    if (stoppedBy !== undefined)
+        process.exitCode = stoppedBy === 'SIGINT' ? 130 : 143;
+}

package/dist/terminal.js

@@ -0,0 +1,125 @@
+// terminal.ts — ANSI rendering for stream output
+//
+// Uses 256-color palette for refined, modern colors.
+// All codes: \x1b[38;5;Nm (foreground), \x1b[48;5;Nm (background)
+import { renderRoomChangeText } from './presentation.js';
+import { formatRelativeTime } from './time.js';
+// Base resets
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const ITALIC = '\x1b[3m';
+const UNDERLINE = '\x1b[4m';
+// Palette (256-color)
+// Soft, muted tones that work well on dark terminals.
+const SAGE = '\x1b[38;5;114m'; // header accent
+const SOFT_BLUE = '\x1b[38;5;111m'; // participant names
+const WARM_AMBER = '\x1b[38;5;222m'; // @mentions, highlights
+const SOFT_CYAN = '\x1b[38;5;117m'; // inline code
+const BODY_GRAY = '\x1b[38;5;250m'; // body text (slightly dimmer than default)
+const META_GRAY = '\x1b[38;5;244m'; // metadata (time, #N)
+const BAR_GRAY = '\x1b[38;5;238m'; // left border bar
+const FAINT = '\x1b[38;5;236m'; // bracket thoughts, waiting
+const RULE_GRAY = '\x1b[38;5;236m'; // horizontal rules
+// Cursor / screen
+export function enableRawMode() {
+    if (!process.stdin.isTTY)
+        return;
+    if (typeof process.stdin.setRawMode === 'function')
+        process.stdin.setRawMode(true);
+    process.stdin.resume();
+}
+export function disableRawMode() {
+    if (!process.stdin.isTTY)
+        return;
+    if (typeof process.stdin.setRawMode === 'function')
+        process.stdin.setRawMode(false);
+}
+function writeControl(sequence) {
+    if (process.stdout.isTTY)
+        process.stdout.write(sequence);
+}
+export function enterAlternateScreen() {
+    writeControl('\x1b[?1049h');
+}
+export function leaveAlternateScreen() {
+    writeControl('\x1b[?1049l');
+}
+export function clearScreen() {
+    writeControl('\x1b[2J\x1b[H');
+}
+export function clearLine() {
+    writeControl('\x1b[2K\r');
+}
+export function cursorUp(n) {
+    if (n > 0)
+        writeControl(`\x1b[${n}A`);
+}
+export function hideCursor() {
+    writeControl('\x1b[?25l');
+}
+export function showCursor() {
+    writeControl('\x1b[?25h');
+}
+// Inline markdown
+function renderInline(body) {
+    let out = body;
+    // Fenced code blocks
+    out = out.replace(/```(\w+)?\n?([\s\S]*?)```/g, (_, _lang, code) => {
+        const lines = code.trimEnd().split('\n');
+        return '\n' + lines.map((l) => `${BAR_GRAY}  ${SOFT_CYAN}${l}${RESET}`).join('\n') + '\n';
+    });
+    // Inline code
+    out = out.replace(/`([^`]+)`/g, (_, code) => `${SOFT_CYAN}${code}${RESET}`);
+    // Bold
+    out = out.replace(/\*\*([^*]+)\*\*/g, (_, text) => `${BOLD}${text}${RESET}`);
+    // Gesture / italic (must come after bold)
+    out = out.replace(/\*([^*]+)\*/g, (_, text) => `${ITALIC}${BODY_GRAY}${text}${RESET}`);
+    // Bracket thoughts (private)
+    out = out.replace(/``\s*\[([^\]]*)\]\s*``/g, (_, thought) => `${FAINT}${ITALIC}[${thought}]${RESET}`);
+    // @mentions
+    out = out.replace(/@([\p{L}\p{N}_-]+)/gu, (_, name) => `${WARM_AMBER}@${name}${RESET}`);
+    // Headers (strip # markers, render bold+underline)
+    out = out.replace(/^#{1,3}\s+(.+)$/gm, (_, text) => `${BOLD}${UNDERLINE}${text}${RESET}`);
+    return out;
+}
+// Event renderer
+export function renderStreamEvent(event, now, actNumber) {
+    switch (event.kind) {
+        case 'say': {
+            const name = `${SOFT_BLUE}${BOLD}${event.actor}${RESET}`;
+            const meta = `${META_GRAY}#${actNumber ?? 1}  ·  ${formatRelativeTime(event.at, now)}${RESET}`;
+            const body = renderInline(event.body)
+                .split('\n')
+                .map((line) => `${BAR_GRAY}·${RESET}  ${line}`)
+                .join('\n');
+            return `\n${name}  ${meta}\n${body}\n`;
+        }
+        case 'done': {
+            const name = `${META_GRAY}${BOLD}${event.actor}${RESET}`;
+            const meta = `${META_GRAY}done · ${formatRelativeTime(event.at, now)}${RESET}`;
+            const body = event.body
+                ? `\n${renderInline(event.body).split('\n').map((line) => `${BAR_GRAY}·${RESET}  ${line}`).join('\n')}`
+                : '';
+            return `\n${name}  ${meta}${body}\n`;
+        }
+        case 'join':
+        case 'hold':
+        case 'resume':
+            return `\n${META_GRAY}${renderRoomChangeText(event)} · ${formatRelativeTime(event.at, now)}${RESET}\n`;
+        default:
+            return '';
+    }
+}
+// Header
+export function renderStreamHeader(squarePath, participantCount, activeCount) {
+    const accent = `${SAGE}· the square${RESET}`;
+    const path = `${META_GRAY}${squarePath}${RESET}`;
+    const stats = `${META_GRAY}${participantCount} participants · ${activeCount} active${RESET}`;
+    const rule = `${RULE_GRAY}${'─'.repeat(60)}${RESET}`;
+    return `\n  ${accent} · ${path}\n  ${stats}\n  ${rule}`;
+}
+// Waiting indicator
+export function renderWaiting() {
+    return `\n${FAINT}  ─── waiting ───${RESET}\n`;
+}

package/dist/time.js

@@ -0,0 +1,81 @@
+function pad(value, length = 2) {
+    return String(value).padStart(length, '0');
+}
+function formatOffset(date) {
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? '+' : '-';
+    const abs = Math.abs(offsetMinutes);
+    return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+export function formatTimestamp(at) {
+    const date = new Date(at);
+    const time = date.getMilliseconds() !== 0
+        ? `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`
+        : date.getSeconds() !== 0
+            ? `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
+            : `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+    return [
+        `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`,
+        time,
+        formatOffset(date),
+    ].join(' ');
+}
+export function formatDuration(ms) {
+    if (ms === undefined)
+        return 'a while';
+    if (ms < 1000)
+        return `${Math.max(0, ms)}ms`;
+    const seconds = Math.ceil(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60)
+        return remainingSeconds === 0 ? `${minutes}m` : `${minutes}m ${remainingSeconds}s`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes === 0 ? `${hours}h` : `${hours}h ${remainingMinutes}m`;
+}
+export function formatRelativeTime(at, now) {
+    const diff = Math.max(0, (now ?? Date.now()) - at);
+    const seconds = Math.floor(diff / 1000);
+    if (seconds < 10)
+        return 'just now';
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    return formatTimestamp(at);
+}
+export function parseTimestamp(value) {
+    const trimmed = value.trim();
+    const local = trimmed.match(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?) ([+-]\d{2}:\d{2})$/);
+    const normalized = local ? `${local[1]}T${local[2]}${local[3]}` : trimmed;
+    return Date.parse(normalized);
+}
+/** Relative offsets like -3d, -24h, -30m, -90s; absolute timestamps via parseTimestamp. */
+export function parseTimeOrRelative(value, now = Date.now()) {
+    const trimmed = value.trim();
+    const relative = trimmed.match(/^(-?)(\d+)(ms|s|m|h|d)$/i);
+    if (relative) {
+        const sign = relative[1] === '-' ? -1 : 1;
+        const amount = Number(relative[2]);
+        const unit = relative[3].toLowerCase();
+        const multipliers = {
+            ms: 1,
+            s: 1000,
+            m: 60_000,
+            h: 3_600_000,
+            d: 86_400_000,
+        };
+        return now + sign * amount * multipliers[unit];
+    }
+    return parseTimestamp(trimmed);
+}

package/dist/wake-sink.js

@@ -0,0 +1,219 @@
+/**
+ * wake-sink.ts — shared paseo wake dispatch.
+ *
+ * This is the single canonical implementation of "wake a paseo agent
+ * when they receive an undelivered @mention or --bell in a square."
+ *
+ * The detached one-shot notification worker uses this module after the
+ * natural-delivery grace period. The WakeSink is stateless; the worker owns
+ * receipt checks, timing, and failure isolation.
+ */
+import { execSync, spawnSync } from 'node:child_process';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { homedir } from 'node:os';
+import { loadSquare } from './artifact.js';
+import { SquareError } from './model.js';
+import { leaseOwnsNotification } from './delivery.js';
+import { sessionInbox } from './inbox.js';
+import { waitForPaseoToolBoundary } from './paseo-timeline.js';
+import { hasPresentedAttention, presentOnce } from './presented.js';
+import { lookupParticipant } from './registry.js';
+import { quoteShell } from './presentation.js';
+import { isDeliveryDelivered, resolveRosterName } from './runtime.js';
+async function waitForCatchDelivery(squarePath, recipient, notification, ownerId) {
+    const deadline = Date.now() + 180_000;
+    while (Date.now() < deadline) {
+        const doc = loadSquare(squarePath);
+        const known = resolveRosterName(doc, recipient) ?? recipient;
+        if (isDeliveryDelivered(doc, known, notification.item.index))
+            return true;
+        const lease = lookupParticipant(squarePath, known).find((binding) => binding.ownerId === ownerId);
+        const activeLease = lease === undefined
+            ? undefined
+            : sessionInbox(lease.sessionId).find((membership) => membership.name === known)?.catchLease;
+        if (activeLease === undefined || activeLease.expiresAt <= Date.now())
+            return false;
+        await sleep(Math.min(250, Math.max(1, activeLease.expiresAt - Date.now())));
+    }
+    return false;
+}
+const DEFAULT_PASEO_WAKE_TIMEOUT_MS = 90_000;
+function paseoWakeTimeoutMs() {
+    const raw = process.env['SQUARE_PASEO_WAKE_TIMEOUT_MS'];
+    if (raw === undefined)
+        return DEFAULT_PASEO_WAKE_TIMEOUT_MS;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new SquareError('invalid_args', 'Invalid SQUARE_PASEO_WAKE_TIMEOUT_MS: expected a positive integer.');
+    }
+    return value;
+}
+// ── helpers ──────────────────────────────────────────────────────
+function previewBody(body) {
+    return body.length > 200 ? body.slice(0, 197) + '...' : body;
+}
+function wakeNowCommand(squarePath, recipient) {
+    return `square --as ${quoteShell(recipient)} --square-path ${quoteShell(squarePath)} catch --now`;
+}
+function nativeWakePrompt(squarePath, recipient) {
+    return [
+        '<system-reminder source="square">',
+        `Square activity is waiting for @${recipient} in ${squarePath}.`,
+        'The native adapter will present it at the next boundary. If it does not:',
+        `\`${wakeNowCommand(squarePath, recipient)}\``,
+        '</system-reminder>',
+    ].join('\n');
+}
+function fullWakePrompt(notification, squarePath) {
+    const { item, recipient } = notification;
+    const home = homedir();
+    const displayPath = squarePath.startsWith(home) ? `~${squarePath.slice(home.length)}` : squarePath;
+    return [
+        '<system-reminder source="square">',
+        `Mentioned by @${item.act.actor} in \`${displayPath}\``,
+        '',
+        `> ${previewBody(item.act.body).replace(/\n/g, '\n> ')}`,
+        '',
+        'To catch up and keep presence current:',
+        `\`${wakeNowCommand(squarePath, recipient)}\``,
+        '',
+        '*(Async notification from Square.)*',
+        '</system-reminder>',
+    ].join('\n');
+}
+function hasNativeGuarantee(bindings, ownerId) {
+    return bindings.some((binding) => binding.ownerId === ownerId &&
+        (binding.channel === 'claude-code' ||
+            binding.channel === 'codex' ||
+            binding.channel === 'opencode' ||
+            binding.channel === 'pi'));
+}
+function sendPaseoPrompt(agentId, prompt) {
+    const result = spawnSync('paseo', ['send', agentId, '--prompt', prompt, '--no-wait'], {
+        stdio: 'ignore',
+        timeout: 5000,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0)
+        throw new Error(`paseo send exited with ${result.status ?? 'no status'}`);
+}
+// ── paseo agent discovery ────────────────────────────────────────
+/** List all paseo agents. Returns empty array if paseo is unavailable. */
+export function listPaseoAgents() {
+    try {
+        return JSON.parse(execSync('paseo ls --json', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Wait for the tool calls that are running now to finish. Calls that start
+ * afterward are deliberately ignored: the transitional wake policy allows
+ * `paseo send` to replace the next call.
+ */
+export async function waitForToolEnd(agentId, timeoutMs) {
+    return waitForPaseoToolBoundary(agentId, {
+        timeoutMs: timeoutMs ?? paseoWakeTimeoutMs(),
+    });
+}
+// ── paseo wake dispatch ──────────────────────────────────────────
+/**
+ * Dispatch a paseo send wake prompt for a single notification.
+ *
+ * Resolves exact Paseo agent ids from the machine-local participant registry.
+ * Idle agents receive the wake immediately. Running agents wait for the
+ * current tool call boundary; the following `paseo send` may replace the next
+ * call by design.
+ */
+export function selectPaseoWakeAgents(squarePath, recipient, agents = listPaseoAgents()) {
+    const ids = new Set(lookupParticipant(squarePath, recipient)
+        .map((binding) => binding.paseoAgentId)
+        .filter((id) => id !== undefined));
+    return agents.filter((agent) => ids.has(agent.id) && (agent.status === 'running' || agent.status === 'idle'));
+}
+export async function dispatchPaseoWake(notification, ctx) {
+    const { item, recipient } = notification;
+    const bindings = lookupParticipant(ctx.squarePath, recipient);
+    const activeAgents = selectPaseoWakeAgents(ctx.squarePath, recipient);
+    if (activeAgents.length === 0)
+        return;
+    const wokenOwners = new Set();
+    for (const active of activeAgents) {
+        if (active.status === 'running') {
+            const reachedBoundary = await waitForToolEnd(active.id);
+            if (!reachedBoundary)
+                continue;
+        }
+        // Re-read after the tool wait: harness inject may have presented during the wait.
+        try {
+            const doc = loadSquare(ctx.squarePath);
+            const known = resolveRosterName(doc, recipient) ?? recipient;
+            if (isDeliveryDelivered(doc, known, item.index))
+                return;
+            if (hasPresentedAttention(ctx.squarePath, known, item.index))
+                return;
+        }
+        catch {
+            // Receipt re-read failure fails open toward wake.
+        }
+        const binding = bindings.find((candidate) => candidate.paseoAgentId === active.id);
+        if (binding === undefined || wokenOwners.has(binding.ownerId))
+            continue;
+        try {
+            const catchMembership = sessionInbox(binding.sessionId).find((membership) => membership.name === (resolveRosterName(loadSquare(ctx.squarePath), recipient) ?? recipient) &&
+                membership.catchLease !== undefined &&
+                leaseOwnsNotification(membership.catchLease, {
+                    actor: item.act.actor,
+                    body: item.act.body,
+                    via: notification.via === 'bell' ? 'bell' : 'mention',
+                }));
+            if (catchMembership?.catchLease !== undefined) {
+                if (await waitForCatchDelivery(ctx.squarePath, recipient, notification, binding.ownerId))
+                    return;
+                const current = lookupParticipant(ctx.squarePath, recipient).find((candidate) => candidate.paseoAgentId === active.id);
+                if (current?.ownerId !== binding.ownerId)
+                    continue;
+                const doc = loadSquare(ctx.squarePath);
+                const known = resolveRosterName(doc, recipient) ?? recipient;
+                if (isDeliveryDelivered(doc, known, item.index) ||
+                    hasPresentedAttention(ctx.squarePath, known, item.index)) {
+                    return;
+                }
+            }
+            if (hasNativeGuarantee(bindings, binding.ownerId)) {
+                sendPaseoPrompt(active.id, nativeWakePrompt(ctx.squarePath, recipient));
+                wokenOwners.add(binding.ownerId);
+                continue;
+            }
+            presentOnce(binding.sessionId, (sessionId) => sessionInbox(sessionId)
+                .map((membership) => ({
+                ...membership,
+                notifications: membership.notifications.filter((candidate) => candidate.actIndex === item.index),
+            }))
+                .filter((membership) => membership.notifications.length > 0), () => sendPaseoPrompt(active.id, fullWakePrompt(notification, ctx.squarePath)));
+            wokenOwners.add(binding.ownerId);
+        }
+        catch {
+            // Paseo unavailable: notification remains unpresented for a later retry.
+        }
+    }
+}
+// ── WakeSink factory ─────────────────────────────────────────────
+/** Create the default paseo WakeSink used by both sync and async paths. */
+export function paseoWakeSink() {
+    return {
+        name: 'paseo',
+        dispatch: dispatchPaseoWake,
+    };
+}
+/** Default sink list, respecting SQUARE_DISABLE_PASEO_WAKE. */
+export function defaultWakeSinks() {
+    if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
+        return [];
+    return [paseoWakeSink()];
+}