@astrosheep/square 0.3.20 → 0.3.22

package/dist/notifications.js

@@ -8,8 +8,7 @@ import { hasPresentedAttention } from './presented.js';
 import { SquareError } from './model.js';
 import { SLEEP_MS, matchesMentionTarget } from './runtime.js';
 import { parseActivityId } from './square-core.js';
-import { quoteShell } from './presentation.js';
-import { renderAttentionPreview } from './attention-presentation.js';
+import { displayAttentionPath, renderAttentionPreview } from './attention-presentation.js';
 import { lookupParticipant } from './registry.js';
 import { retireWakeRoute } from './routes.js';
 import { openSquare } from './square-file-adapter.js';
@@ -30,12 +29,17 @@ export function wakeGraceMs(env = process.env) {
     }
     return value;
 }
-function catchCommand(squarePath, recipient) {
-    return `square --as ${quoteShell(recipient)} --location ${quoteShell(squarePath)} catch --now`;
+function wakeLabel(kind) {
+    if (kind === 'paseo')
+        return 'paseo';
+    if (kind.startsWith('codex'))
+        return 'codex-queue';
+    return kind;
 }
-function renderWakePayload(request, body) {
+function renderWakePayload(request, body, kind) {
     return [
-        '<system-reminder source="square">',
+        `<system-reminder source="square" wake="${wakeLabel(kind)}">`,
+        `square: ${displayAttentionPath(request.squarePath)}`,
         renderAttentionPreview({
             squarePath: request.squarePath,
             actIndex: request.actIndex,
@@ -43,9 +47,8 @@ function renderWakePayload(request, body) {
             actor: request.actor,
             route: request.route,
             body,
+            compact: true,
         }),
-        'The native adapter presented this attention. If you have not acted on it, pull from the square yourself.',
-        `\`${catchCommand(request.squarePath, request.recipient)}\``,
         '</system-reminder>',
     ].join('\n');
 }
@@ -181,7 +184,7 @@ async function processNotification(squarePath, notification, opts) {
             actor: notification.item.actor,
             route: notification.route,
         };
-        await port.dispatch(evidence.attemptableRoutes, renderWakePayload(request, notification.item.body), {
+        await port.dispatch(evidence.attemptableRoutes, (route) => renderWakePayload(request, notification.item.body, route.kind), {
             nextAttemptN: () => nextWakeAttemptNumber(attention, { env, now: now() }),
             beforeSend: async (route, attemptN) => {
                 if (await waitForCatch(route, request, notification.item.body))

package/dist/participant-identity.d.ts

@@ -1 +1,5 @@
 export declare function participantIdentity(name: string): string;
+export type AutomaticProvider = 'codex' | 'claude' | 'opencode' | 'pi';
+export declare function automaticParticipant(provider: AutomaticProvider, sessionId: string, env: NodeJS.ProcessEnv): string;
+/** Compute the current harness participant without reading a Square or registry artifact. */
+export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;

package/dist/participant-identity.js

@@ -1,3 +1,35 @@
+import { createHash } from 'node:crypto';
+import { validateName } from './model.js';
 export function participantIdentity(name) {
     return `@${name}`;
 }
+const nativeSessions = [
+    { variable: 'CLAUDE_CODE_SESSION_ID', provider: 'claude' },
+    { variable: 'CODEX_THREAD_ID', provider: 'codex' },
+    { variable: 'OPENCODE_SESSION_ID', provider: 'opencode' },
+    { variable: 'SQUARE_PI_SESSION_ID', provider: 'pi' },
+];
+export function automaticParticipant(provider, sessionId, env) {
+    const configured = env.SQUARE_PARTICIPANT_NAME?.trim();
+    if (configured) {
+        validateName(configured);
+        return configured;
+    }
+    const digest = createHash('sha256').update(sessionId, 'utf8').digest('hex').slice(0, 12);
+    return `${provider}-${digest}`;
+}
+/** Compute the current harness participant without reading a Square or registry artifact. */
+export function squareAssignedParticipantName(env = process.env) {
+    const configured = env.SQUARE_PARTICIPANT_NAME?.trim();
+    if (configured) {
+        validateName(configured);
+        return configured;
+    }
+    const names = new Set(nativeSessions
+        .map(({ variable, provider }) => {
+        const sessionId = env[variable]?.trim();
+        return sessionId === undefined || sessionId === '' ? undefined : automaticParticipant(provider, sessionId, env);
+    })
+        .filter((name) => name !== undefined));
+    return names.size === 1 ? [...names][0] : undefined;
+}

package/dist/paseo-delivery.js

@@ -51,12 +51,12 @@ export class PaseoAdapter {
             };
         }
         const agent = discovery.agents.find((candidate) => candidate.id === agentId);
-        if (agent === undefined || (agent.status !== 'idle' && agent.status !== 'running')) {
+        if (agent === undefined || agent.status !== 'idle') {
             return {
                 outcome: 'unavailable',
-                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'),
+                signature: agent === undefined ? 'address_not_found' : 'agent_not_idle',
+                message: agent === undefined ? 'The registered Paseo agent was not found.' : 'The registered Paseo agent is not idle.',
+                diagnostic: diagnostic('selection', address, agent === undefined ? 'not_found' : 'not_idle'),
                 ...(agent === undefined ? {} : { retainRoute: true }),
             };
         }

package/dist/presentation.js

@@ -179,7 +179,7 @@ function renderPresenceOnlySay(event, opts = {}) {
     const audience = audienceOf(event);
     const targets = audience.kind === 'bell' ? [] : audience.names;
     if (targets.length === 0) {
-        return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}\n  spoke`;
+        return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}`;
     }
     const dest = ` ${targets.map((name) => participantIdentity(name)).join(' and ')}`;
     return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}\n  talked to${dest}`;

package/dist/presented.d.ts

@@ -8,6 +8,6 @@ export declare function recordPresentedForOwner(ownerId: string, squarePath: str
 /**
  * Serialize presentation only for the affected participants. Delivery runs
  * outside the short ledger-write lock, so unrelated owners never wait on an
- * adapter. A throwing callback leaves no row and remains unpresented.
+ * adapter. A throwing or rejecting callback leaves no row and remains unpresented.
  */
-export declare function presentOnce<T>(sessionId: string, lookup: (sessionId: string) => InboxMembership[], deliver: (inbox: InboxMembership[]) => T, env?: NodeJS.ProcessEnv, at?: number): T | undefined;
+export declare function presentOnce<T>(sessionId: string, lookup: (sessionId: string) => InboxMembership[] | Promise<InboxMembership[]>, deliver: (inbox: InboxMembership[]) => T | Promise<T>, env?: NodeJS.ProcessEnv, at?: number): Promise<T | undefined>;

package/dist/presented.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
-import { withFileLockSync } from './file-lock.js';
+import { withFileLock, withFileLockSync } from './file-lock.js';
 import { canonicalSquarePath, lookupParticipant, lookupSessionBindings } from './registry.js';
 import { sameName } from './model.js';
 const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
@@ -72,6 +72,15 @@ function withAttentionLocks(filePath, inbox, fn) {
     }
     return acquire(0);
 }
+async function withAttentionLocksAsync(filePath, inbox, fn) {
+    const lockPaths = [...new Set(inbox.map((membership) => attentionLockPath(filePath, membership)))].sort();
+    async function acquire(index) {
+        if (index >= lockPaths.length)
+            return fn();
+        return withFileLock(lockPaths[index], { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => acquire(index + 1));
+    }
+    return acquire(0);
+}
 function ownerFor(sessionId, membership) {
     const squarePath = canonicalSquarePath(membership.squarePath);
     const binding = lookupSessionBindings(sessionId).find((candidate) => candidate.squarePath === squarePath && sameName(candidate.name, membership.name));
@@ -129,21 +138,21 @@ export function recordPresentedForOwner(ownerId, squarePath, name, actIndex, env
 /**
  * Serialize presentation only for the affected participants. Delivery runs
  * outside the short ledger-write lock, so unrelated owners never wait on an
- * adapter. A throwing callback leaves no row and remains unpresented.
+ * adapter. A throwing or rejecting callback leaves no row and remains unpresented.
  */
-export function presentOnce(sessionId, lookup, deliver, env = process.env, at = Date.now()) {
+export async function presentOnce(sessionId, lookup, deliver, env = process.env, at = Date.now()) {
     const filePath = presentedPath(env);
-    const initial = lookup(sessionId).filter((membership) => membership.notifications.length > 0);
+    const initial = (await lookup(sessionId)).filter((membership) => membership.notifications.length > 0);
     if (initial.length === 0)
         return undefined;
     const lockedMemberships = new Set(initial.map(membershipKey));
-    return withAttentionLocks(filePath, initial, () => {
-        const current = lookup(sessionId).filter((membership) => lockedMemberships.has(membershipKey(membership)));
+    return withAttentionLocksAsync(filePath, initial, async () => {
+        const current = (await lookup(sessionId)).filter((membership) => lockedMemberships.has(membershipKey(membership)));
         const selected = selectUnpresented(sessionId, current, readRows(filePath, at));
         if (selected.length === 0)
             return undefined;
-        const result = deliver(selected.map(({ membership }) => membership));
-        withFileLockSync(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
+        const result = await deliver(selected.map(({ membership }) => membership));
+        await withFileLock(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
             const rows = readRows(filePath, at);
             const known = new Set(rows.map(rowKey));
             for (const { membership, ownerId } of selected) {

package/dist/registry.d.ts

@@ -37,15 +37,15 @@ export declare function lookupParticipant(squarePath: string, name: string, now?
 /** Resolve the current local harness owner for a participant, if one is registered. */
 export declare function localParticipantOwner(squarePath: string, name: string, env?: NodeJS.ProcessEnv, now?: number): string | undefined;
 export declare function localParticipantName(squarePath: string, env?: NodeJS.ProcessEnv): string | undefined;
-/** Resolve the one participant name owned by the current local session set, without a square path. */
-export declare function assignedSquareName(env?: NodeJS.ProcessEnv): string | undefined;
+/** Compute the current participant from the live harness identity, without registry history. */
+export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
 export type CurrentParticipantBinding = Readonly<{
     created: boolean;
     ownerId: string;
 }>;
-/** Bind a current local session to one explicit square without taking an occupied registry name. */
+/** Bind the current harness to one explicit Square participant. */
 export declare function bindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): CurrentParticipantBinding;
-/** Retire only the current local session bindings for one explicit square and participant. */
+/** Retire only this harness's binding for one Square participant. */
 export declare function unbindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): boolean;
 export interface RegistryPruneResult {
     removed: number;

package/dist/registry.js

@@ -12,6 +12,7 @@ import { randomUUID } from 'node:crypto';
 import { nameKey, sameName, SquareError } from './model.js';
 import { isCurrentlyJoined } from './runtime.js';
 import { publishWakeRoutes, retireOwnerWakeRoutes } from './routes.js';
+import { squareAssignedParticipantName as computeSquareAssignedParticipantName } from './participant-identity.js';
 const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 const COMPACT_BYTES = 64 * 1024;
 const COMPACT_LINES = 1000;
@@ -236,15 +237,14 @@ export function localParticipantName(squarePath, env = process.env) {
     const names = new Set(identities.flatMap((identity) => lookupSession(identity.sessionId).filter((item) => canonicalSquarePath(item.squarePath) === canonicalSquarePath(squarePath)).map((item) => item.name)));
     return names.size === 1 ? [...names][0] : undefined;
 }
-/** Resolve the one participant name owned by the current local session set, without a square path. */
-export function assignedSquareName(env = process.env) {
-    const names = new Set(localSessionIdentities(env).flatMap((identity) => lookupSession(identity.sessionId).map((item) => item.name)));
-    return names.size === 1 ? [...names][0] : undefined;
+/** Compute the current participant from the live harness identity, without registry history. */
+export function squareAssignedParticipantName(env = process.env) {
+    return computeSquareAssignedParticipantName(env);
 }
-/** Bind a current local session to one explicit square without taking an occupied registry name. */
+/** Bind the current harness to one explicit Square participant. */
 export function bindCurrentParticipant(squarePath, name, env = process.env) {
-    if (assignedSquareName(env) !== name) {
-        throw new SquareError('invalid_args', `The current session is not uniquely bound to ${name}`);
+    if (squareAssignedParticipantName(env) !== name) {
+        throw new SquareError('invalid_args', `The current session is not assigned ${name}`);
     }
     const localOwner = localParticipantOwner(squarePath, name, env);
     if (localOwner !== undefined)
@@ -259,7 +259,7 @@ export function bindCurrentParticipant(squarePath, name, env = process.env) {
         throw new Error(`Current participant binding did not commit for ${name}`);
     return { created: true, ownerId };
 }
-/** Retire only the current local session bindings for one explicit square and participant. */
+/** Retire only this harness's binding for one Square participant. */
 export function unbindCurrentParticipant(squarePath, name, env = process.env) {
     const identities = new Set(localSessionIdentities(env).map((identity) => identity.sessionId));
     const current = lookupParticipant(squarePath, name).filter((binding) => identities.has(binding.sessionId));

package/dist/routes.d.ts

@@ -30,9 +30,9 @@ export interface WakeRouteEvidence {
 export type WakeRouteProbe = (env: NodeJS.ProcessEnv) => WakeRouteEvidence | undefined;
 /**
  * One probe per kind. A probe publishes only when its provider's complete
- * endpoint evidence is present; session identity alone never publishes. The
- * four native transports have no endpoint lifecycle in this delivery, so
- * their probes publish nothing until those transports land.
+ * endpoint evidence is present; Codex uses its thread id as that evidence.
+ * The other native transports have no endpoint lifecycle in this delivery,
+ * so their probes publish nothing until those transports land.
  */
 export declare const WAKE_ROUTE_PROBES: Readonly<Record<WakeRouteKind, WakeRouteProbe>>;
 /** The kind-neutral publication loop; probes supply complete evidence per kind. */

package/dist/routes.js

@@ -139,9 +139,9 @@ function completeRouteEvidence(value) {
 }
 /**
  * One probe per kind. A probe publishes only when its provider's complete
- * endpoint evidence is present; session identity alone never publishes. The
- * four native transports have no endpoint lifecycle in this delivery, so
- * their probes publish nothing until those transports land.
+ * endpoint evidence is present; Codex uses its thread id as that evidence.
+ * The other native transports have no endpoint lifecycle in this delivery,
+ * so their probes publish nothing until those transports land.
  */
 export const WAKE_ROUTE_PROBES = {
     'opencode-server': () => undefined,

package/dist/square-core.d.ts

@@ -79,6 +79,8 @@ export interface FoldedSquareState {
     throttleActivityAts: number[];
     bellSayAtsByActor: Map<string, number[]>;
     listening: Map<string, Participant[]>;
+    /** Derived sender blocks; kept outside the artifact schema. */
+    ignored: Map<string, Participant[]>;
 }
 export type ValidationResult = {
     ok: true;
@@ -117,6 +119,7 @@ export declare function audienceOf(say: {
 export declare function audienceIncludes(audience: Audience, name: string): boolean;
 export declare function resolveAudience(audience: Audience, candidateNames: readonly string[]): string[];
 export declare function activeListeners(state: FoldedSquareState, sender: string): string[];
+export declare function isIgnored(state: FoldedSquareState, listener: string, sender: string): boolean;
 export declare function audienceBefore(acts: readonly Act[], say: Extract<Act, {
     kind: 'say';
 }>): string[];

package/dist/square-core.js

@@ -59,18 +59,26 @@ export function resolveAudience(audience, candidateNames) {
 }
 export function activeListeners(state, sender) {
     return state.participants
-        .filter((participant) => participant.joined && (state.listening.get(nameKey(participant.name)) ?? []).some((target) => sameName(target, sender)))
+        .filter((participant) => participant.joined
+        && !(state.ignored.get(nameKey(participant.name)) ?? []).some((target) => sameName(target, sender))
+        && (state.listening.get(nameKey(participant.name)) ?? []).some((target) => sameName(target, sender)))
         .map((participant) => participant.name);
 }
+export function isIgnored(state, listener, sender) {
+    return (state.ignored.get(nameKey(listener)) ?? []).some((target) => sameName(target, sender));
+}
 export function audienceBefore(acts, say) {
     const position = acts.findIndex((act) => act === say || ('index' in act && 'index' in say && act.index === say.index));
     const before = fold(position < 0 ? acts : acts.slice(0, position));
-    const mentionTargets = resolveAudience(audienceOf(say), before.joined);
+    const audience = audienceOf(say);
+    const mentionTargets = resolveAudience(audience, before.joined);
     const listeners = activeListeners(before, say.actor);
     const recipients = [];
     for (const name of [...mentionTargets, ...listeners]) {
         if (sameName(name, say.actor) || recipients.some((existing) => sameName(existing, name)))
             continue;
+        if (audience.kind !== 'bell' && isIgnored(before, name, say.actor))
+            continue;
         recipients.push(name);
     }
     return recipients;
@@ -146,6 +154,7 @@ export function fold(acts) {
         throttleActivityAts: [],
         bellSayAtsByActor: new Map(),
         listening: new Map(),
+        ignored: new Map(),
     };
     for (const act of acts) {
         const actor = actorOf(act);
@@ -172,6 +181,11 @@ export function fold(acts) {
                 if (!targets.some((target) => sameName(target, act.target)))
                     targets.push(act.target);
                 state.listening.set(key, targets);
+                const ignored = (state.ignored.get(key) ?? []).filter((target) => !sameName(target, act.target));
+                if (ignored.length === 0)
+                    state.ignored.delete(key);
+                else
+                    state.ignored.set(key, ignored);
                 break;
             }
             case 'ignore': {
@@ -181,6 +195,10 @@ export function fold(acts) {
                     state.listening.delete(key);
                 else
                     state.listening.set(key, targets);
+                const ignored = state.ignored.get(key) ?? [];
+                if (!ignored.some((target) => sameName(target, act.target)))
+                    ignored.push(act.target);
+                state.ignored.set(key, ignored);
                 break;
             }
             case 'say':

package/dist/square-file-adapter.d.ts

@@ -1,5 +1,5 @@
 import { type BuildOptions, type HardCap } from './model.js';
-import type { OpenSquare } from './open-square.js';
+import { type OpenSquare } from './open-square.js';
 import type { WakeNotifier } from './square-facade.js';
 /** File-owned artifact creation for the CLI and path-backed public facade. */
 export declare function createSquare(squarePath: string, options: BuildOptions & {
@@ -16,3 +16,13 @@ export declare function openSquare(squarePath: string, options?: Pick<SquareBuil
 export declare function probeSquare(squarePath: string): OpenSquare | undefined;
 export declare function buildSquare(squarePath: string, options: SquareBuildOptions): Promise<OpenSquare>;
 export declare function buildMemorySquare(options: SquareBuildOptions): OpenSquare;
+/** Wait for any bound artifact to change; delivery callers re-project after the edge. */
+export type SquareChangeWaitResult<T> = {
+    status: 'ready';
+    value: T;
+} | {
+    status: 'changed';
+} | {
+    status: 'expired';
+};
+export declare function waitForSquareChanges<T>(squarePaths: readonly string[], timeoutMs: number, signal?: AbortSignal, afterReady?: () => Promise<T | undefined>): Promise<SquareChangeWaitResult<T>>;

package/dist/square-file-adapter.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { createSquareState, probeSquareFile, writeSquareSnapshot, withSquareFileLock, openSquareCell, createMemoryCell, } from './square-storage.js';
 import { InternalSquareError, SquareError, } from './model.js';
+import { closeOpenSquare } from './open-square.js';
 /** The current CLI file mutation boundary. */
 function writeSquareState(squarePath, squareState) {
     writeSquareSnapshot(squarePath, squareState);
@@ -68,3 +69,50 @@ export function buildMemorySquare(options) {
     }, options.markdown);
     return { cell: createMemoryCell(squareState), clock: options.clock ?? Date.now, ...(options.notifier === undefined ? {} : { notifier: options.notifier }), location: 'memory' };
 }
+export async function waitForSquareChanges(squarePaths, timeoutMs, signal, afterReady) {
+    if (timeoutMs <= 0 || signal?.aborted || squarePaths.length === 0)
+        return { status: 'expired' };
+    const squares = [];
+    try {
+        for (const squarePath of [...new Set(squarePaths)]) {
+            try {
+                squares.push(await openSquare(squarePath));
+            }
+            catch { /* stale binding */ }
+        }
+        if (squares.length === 0)
+            return { status: 'expired' };
+        const baselines = await Promise.all(squares.map(async (square) => ({
+            square,
+            version: (await square.cell.read()).version,
+        })));
+        const ready = await afterReady?.();
+        if (ready !== undefined)
+            return { status: 'ready', value: ready };
+        const waits = baselines.map(async ({ square, version }) => {
+            const changed = await square.cell.changed(version, timeoutMs).catch(() => false);
+            if (changed)
+                return true;
+            throw new Error('square wait expired');
+        });
+        let abortWait;
+        const abort = new Promise((resolve) => {
+            abortWait = () => resolve(false);
+            if (signal?.aborted)
+                abortWait();
+            else
+                signal?.addEventListener('abort', abortWait, { once: true });
+        });
+        try {
+            const changed = await Promise.race([Promise.any(waits).catch(() => false), abort]);
+            return changed ? { status: 'changed' } : { status: 'expired' };
+        }
+        finally {
+            if (abortWait)
+                signal?.removeEventListener('abort', abortWait);
+        }
+    }
+    finally {
+        await Promise.all(squares.map((square) => closeOpenSquare(square)));
+    }
+}

package/dist/square-wiring.d.ts

@@ -9,6 +9,10 @@ export declare class Square {
     static build(input: SquareBuildInput): Promise<Square>;
     static inMemory(input: Omit<SquareBuildInput, 'path'>): Square;
     join(name: string): Promise<Participant>;
+    joinWithActivity(name: string): Promise<{
+        readonly participant: Participant;
+        readonly activity: Activity | null;
+    }>;
     implicitJoin(name: string): Promise<{
         readonly state: 'joined' | 'active' | 'done';
         readonly participant?: Participant;

package/dist/square-wiring.js

@@ -59,6 +59,10 @@ export class Square {
         const joined = await join(this.square, name);
         return new ParticipantHandle(joined.name, this.square);
     }
+    async joinWithActivity(name) {
+        const joined = await join(this.square, name);
+        return { participant: new ParticipantHandle(joined.name, this.square), activity: joined.activity };
+    }
     async implicitJoin(name) {
         const joined = await implicitJoin(this.square, name);
         return joined.state === 'done'

package/dist/views.d.ts

@@ -79,7 +79,6 @@ export declare function resolveParticipant(square: OpenSquare, name: string): Pr
     readonly roster: readonly string[];
 }>;
 export declare function currentParticipant(square: OpenSquare, name: string): Promise<string | undefined>;
-export declare function admitsBareExpress(square: OpenSquare, name: string, body: string): Promise<boolean>;
 export declare function participants(square: OpenSquare): Promise<ParticipantStatus[]>;
 export declare function snapshot(square: OpenSquare): Promise<SquareSnapshot>;
 export declare function activityPresentation(square: OpenSquare, name: string): Promise<ActivityPresentation>;

package/dist/views.js

@@ -1,4 +1,4 @@
-import { activeListeners, extractMentions, formatActivityId, parseActivityId } from './square-core.js';
+import { extractMentions, formatActivityId, parseActivityId } from './square-core.js';
 import { deliveryDelta, directedPeerSays } from './activity-feed.js';
 import { coreActivities, coreParticipants, coreStatus, resolveKnownName } from './decisions.js';
 import { deriveDeliveryModel, isActivitySeen, perceiveActivity, planActNotifications } from './delivery.js';
@@ -62,7 +62,6 @@ export async function history(square, query = {}) { const { state } = await squa
 export async function participantHistory(square, name, query = {}) { const { state } = await square.cell.read(); const viewer = resolveKnownName(state, name); const effective = query.all === true || query.limit !== undefined ? query : { ...query, limit: 10 }; return selectHistory(coreActivities(state, historyOptions(effective, viewer)), effective).map((activity) => exposePerceived(state, activity, viewer)); }
 export async function resolveParticipant(square, name) { const { state } = await square.cell.read(); return { name: resolveKnownName(state, name), roster: rosterNames(state) }; }
 export async function currentParticipant(square, name) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name); return known !== undefined && isCurrentlyJoined(state.acts, known) ? known : undefined; }
-export async function admitsBareExpress(square, name, body) { const { state } = await square.cell.read(); const actor = resolveKnownName(state, name); return extractMentions(body).length > 0 || activeListeners(foldedState(state), actor).length > 0; }
 export async function participants(square) { const { state } = await square.cell.read(); return statuses(square, state); }
 export async function snapshot(square) { const { state } = await square.cell.read(); const folded = foldedState(state); return { context: [...state.preamble, ...state.warmup].join('\n'), actCount: state.acts.filter((activity) => activity.kind !== 'read').length, hardCap: state.hardCap, ...(state.throttlePerMinute === undefined ? {} : { throttlePerMinute: state.throttlePerMinute }), held: folded.hold.active && folded.hold.actor !== undefined ? { by: folded.hold.actor, ...(folded.hold.reason === undefined ? {} : { reason: folded.hold.reason }) } : null, participants: statuses(square, state), delivered(name, id) { return isActivitySeen(state, name, parseRequiredActivityId(id)); } }; }
 export async function activityPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const delta = deliveryDelta(state, known); const hold = currentHold(state.acts); return { name: known, roster: rosterNames(state), pendingPublic: directedPeerSays(state, delta, known), pendingRoomChanges: [], activities: state.acts, state, participantCount: inSquareCount(state), held: hold.active, ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: countSays(state.acts, known), hardCap: state.hardCap }; }

package/dist/wake-port.d.ts

@@ -19,5 +19,5 @@ export type WakePortResult = {
 export declare class WakePort {
     private readonly adapters;
     constructor(adapters: WakeAdapter[]);
-    dispatch(routes: readonly WakeRoute[], payload: string, hooks: WakePortHooks): Promise<WakePortResult>;
+    dispatch(routes: readonly WakeRoute[], payload: string | ((route: WakeRoute) => string), hooks: WakePortHooks): Promise<WakePortResult>;
 }

package/dist/wake-port.js

@@ -10,7 +10,7 @@ export class WakePort {
             if (adapter === undefined)
                 continue;
             const attemptN = hooks.nextAttemptN();
-            const result = await adapter.dispatch(route.address, payload, () => hooks.beforeSend(route, attemptN));
+            const result = await adapter.dispatch(route.address, typeof payload === 'function' ? payload(route) : payload, () => hooks.beforeSend(route, attemptN));
             if (result.outcome === 'cancelled')
                 return result;
             if (result.outcome === 'unavailable') {

package/extensions/square-pi.js

@@ -1,5 +1,6 @@
 import { presentPendingAtBoundary, renderPendingAtBoundary } from '../dist/boundary-presentation.js';
 import { automaticSessionEnd, automaticSessionStart } from '../dist/automatic-session.js';
+import { waitForSessionPending } from '../dist/inbox.js';
 
 export function pendingInbox(inbox) {
   return inbox.filter((item) => item.notifications?.length > 0);
@@ -20,14 +21,97 @@ export default function squarePiExtension(pi) {
   let sessionCwd;
   let joiningContext;
   let previousSessionId;
+  let watcher;
+  let watcherAbort;
+  let generation = 0;
+  let presenting = false;
+  let settledSerial = 0;
+  let settledWaiters = [];
+  const handledPending = new Set();
+  let retryAfterChange = false;
   const present = (deliver) => sessionId === undefined ? undefined : presentPendingAtBoundary(sessionId, deliver);
 
+  const waitForSettled = (serial, signal) => {
+    if (settledSerial !== serial) return Promise.resolve();
+    return new Promise((resolve) => {
+      const waiter = { serial, resolve };
+      settledWaiters.push(waiter);
+      if (signal) signal.addEventListener('abort', () => {
+        const index = settledWaiters.indexOf(waiter);
+        if (index >= 0) settledWaiters.splice(index, 1);
+        resolve();
+      }, { once: true });
+    });
+  };
+
+  const wake = async (piContext, token, signal) => {
+    while (sessionId !== undefined && token === generation && !signal.aborted) {
+      const deferredRetry = retryAfterChange;
+      const pending = await waitForSessionPending(sessionId, 30_000, {
+        signal,
+        excludeKeys: handledPending,
+        skipImmediate: deferredRetry,
+      });
+      if (sessionId === undefined || token !== generation || signal.aborted) return;
+      if (pending.length === 0) {
+        if (deferredRetry) retryAfterChange = false;
+        continue;
+      }
+      retryAfterChange = false;
+      if (!piContext.isIdle()) {
+        const serial = settledSerial;
+        await waitForSettled(serial, signal);
+        continue;
+      }
+      if (presenting) continue;
+      const keys = inboxKeys(pending);
+      presenting = true;
+      try {
+        const delivered = await presentPendingAtBoundary(
+          sessionId,
+          async (content) => {
+            await pi.sendMessage(
+              { customType: 'square', content, display: true },
+              { deliverAs: 'steer', triggerTurn: true },
+            );
+            return true;
+          },
+        );
+        if (delivered === true || delivered === undefined) {
+          for (const key of keys) handledPending.add(key);
+        }
+      } catch {
+        // Leave pending evidence untouched so the next state change can retry.
+        retryAfterChange = true;
+      } finally {
+        presenting = false;
+      }
+    }
+  };
+
   pi.on('session_start', async (_event, ctx) => {
+    generation += 1;
+    watcherAbort?.abort();
+    if (watcher) await watcher;
+    watcher = undefined;
+    watcherAbort = undefined;
+    handledPending.clear();
+    retryAfterChange = false;
     sessionId = ctx.sessionManager.getSessionId();
     sessionCwd = ctx.cwd || process.cwd();
     previousSessionId = process.env.SQUARE_PI_SESSION_ID;
     process.env.SQUARE_PI_SESSION_ID = sessionId;
     try { joiningContext = await automaticSessionStart('pi', sessionId, sessionCwd); } catch { joiningContext = undefined; }
+    watcherAbort = new AbortController();
+    const token = generation;
+    watcher = wake(ctx, token, watcherAbort.signal).catch(() => undefined);
+  });
+
+  pi.on('agent_settled', async () => {
+    settledSerial += 1;
+    const waiters = settledWaiters;
+    settledWaiters = [];
+    for (const waiter of waiters) waiter.resolve();
   });
 
   pi.on('before_agent_start', async () => {
@@ -37,6 +121,7 @@ export default function squarePiExtension(pi) {
         joiningContext = undefined;
         return { message: { customType: 'square', content: context, display: true } };
       }
+      if (presenting) return undefined;
       return present((context) => ({ message: { customType: 'square', content: context, display: true } }));
     } catch {
       return undefined;
@@ -44,6 +129,13 @@ export default function squarePiExtension(pi) {
   });
 
   pi.on('session_shutdown', async () => {
+    generation += 1;
+    watcherAbort?.abort();
+    if (watcher) await watcher;
+    watcher = undefined;
+    watcherAbort = undefined;
+    for (const waiter of settledWaiters) waiter.resolve();
+    settledWaiters = [];
     if (sessionId && sessionCwd) await automaticSessionEnd('pi', sessionId, sessionCwd);
     if (process.env.SQUARE_PI_SESSION_ID === sessionId) {
       if (previousSessionId === undefined) delete process.env.SQUARE_PI_SESSION_ID;
@@ -52,5 +144,6 @@ export default function squarePiExtension(pi) {
     sessionId = undefined;
     sessionCwd = undefined;
     joiningContext = undefined;
+    presenting = false;
   });
 }