@astrosheep/square 0.3.105 → 0.4.0

package/dist/delivery.js

@@ -1,96 +1,68 @@
-import { renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
-import { parseActivityId } from './square-core.js';
+import { formatMessageId } from './message.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
-import { automaticDispatchEligible, presentationBlocksDispatch } from './delivery-attempts.js';
-import { matchesCatchSelection } from './catch-selection.js';
-/** Exact stored activity projection for transports that send an awareness reminder. */
-export function wakePreview(facts, request) {
-    const index = parseActivityId(request.activity);
-    const head = index === undefined ? undefined : pendingHead(facts, request.participant, index);
-    const item = index === undefined ? undefined : facts.activity(index);
-    const seat = facts.seat(request.participant);
-    if (head === undefined || item?.kind !== 'say' || seat === undefined || seat.attachment !== 'attached'
-        || deliveryDeferralExpiry(facts, request.seat, item.index, Date.now()) !== undefined)
-        return undefined;
-    return renderSquareReminder([renderAttentionPreview({
-            squarePath: request.location, recipient: request.participant, actIndex: item.index,
-            actor: item.actor, route: head.route, body: item.body ?? '(structured activity)', delivery: item.delivery,
-        })], [item.delivery]);
-}
-function custody(evidence) {
-    return evidence.map(row => ({ purpose: row.kind === 'wake' ? 'dispatch' : 'presentation', outcome: row.outcome, expiresAt: row.expiresAt }));
-}
-/** Presentation custody blocks a wake, independently of native wake acceptance. */
-export function presentationBlocksWake(evidence, now) {
-    return presentationBlocksDispatch(custody(evidence), now);
-}
-/** Preselection only: an expired wake dispatch is uncertain, never safe automatic replay. */
-export function automaticWakeEligible(evidence, now) {
-    return automaticDispatchEligible(custody(evidence), now);
+export { pendingHeadAt, pendingMessageHeads, pendingAddresses, presentationBlocksWake, automaticWakeEligible } from './channel-delivery.js';
+import { pendingHeadAt, pendingMessageHeads } from './channel-delivery.js';
+/** Upper enrichment: the reason this recipient was reached, when an Agora say owns the message. */
+function enriched(facts, head) {
+    const relation = facts.activityByMessage(head.index);
+    return { index: head.index, at: head.at, actor: head.from, recipient: head.recipient,
+        ...(head.generation === undefined ? {} : { generation: head.generation }),
+        ...(relation === undefined ? {} : { activityIndex: relation.index, route: facts.directedAt(head.recipient, relation.index)?.route }) };
 }
 /** Notification pending is not cursor suffix or historical catch membership. */
-export function pendingHead(facts, name, index) {
-    const participant = facts.participant(name);
-    if (!participant?.joined || index <= (participant.lastJoinIndex ?? -1) || facts.receipt(participant.name, index))
-        return undefined;
-    return facts.directedAt(participant.name, index);
+export function pendingHead(facts, name, index, now = Date.now()) {
+    const head = pendingHeadAt(facts.channel, name, index, now);
+    return head === undefined ? undefined : enriched(facts, head);
 }
-/** One activity's landed recipients that still owe a wake; the rest of the roster is untouched. */
-export function pendingRecipients(facts, index) {
-    return facts.audience(index).flatMap(({ recipient }) => {
-        const head = pendingHead(facts, recipient, index);
-        return head === undefined ? [] : [head];
-    });
+export function nativePendingHead(facts, input) {
+    const seat = facts.channel.endpoint(input.participant);
+    if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== input.generation
+        || input.owner !== undefined && seat.owner !== input.owner
+        || !sameWakeAddress(seat.wakeAddress, input.route))
+        return undefined;
+    const cancelledThrough = facts.channel.cancelledThrough(seat.participant, seat.generation);
+    if (input.index <= Math.max(input.cancelledThrough ?? -1, cancelledThrough ?? -1))
+        return undefined;
+    if (deliveryDeferralExpiry(facts.channel, seat, input.index, input.now) !== undefined)
+        return undefined;
+    return pendingHead(facts, seat.participant, input.index, input.now);
 }
-/** Still-pending directed heads for one recipient, oldest first. Bodies belong to presentation. */
-export function pendingHeads(facts, name) {
-    const participant = facts.participant(name);
-    if (!participant?.joined)
-        return [];
-    const heads = [];
-    let afterIndex = participant.lastJoinIndex ?? -1;
-    for (;;) {
-        const page = facts.directed(participant.name, { afterIndex, unseenOnly: true }, { edge: 'oldest', limit: 100 });
-        heads.push(...page.items);
-        if (!page.hasMore)
-            break;
-        afterIndex = page.items.at(-1).index;
-    }
-    return heads;
+/** Still-pending directed messages for one recipient, oldest first. Bodies belong to presentation. */
+export function pendingHeads(facts, name, now = Date.now(), suppress = true) {
+    return pendingMessageHeads(facts.channel, name, now, suppress).map(head => enriched(facts, head));
 }
 export function capturePendingScan(facts) {
-    return { roster: facts.roster().filter((participant) => participant.joined), throughIndex: facts.header().lastActIndex };
+    return { roster: facts.channel.endpoints().filter(endpoint => endpoint.attachment === 'attached').map(endpoint => ({ name: endpoint.participant, generation: endpoint.generation })),
+        throughIndex: facts.channel.header().lastMessageIndex };
 }
 export function sameJoin(facts, captured) {
-    const current = facts.participant(captured.name);
-    return current?.joined === captured.joined && current?.lastJoinIndex === captured.lastJoinIndex;
+    const current = facts.channel.endpoint(captured.name);
+    return current?.attachment === 'attached' && current.generation === captured.generation;
 }
-/** Finite bodyless pass: unrelated revisions never rewind the last examined group. */
+/** Finite bodyless pass: unrelated revisions never rewind the last examined message. */
 export async function* pendingPages(artifact, scan, afterIndex = -1) {
     const captured = new Map(scan.roster.map((participant) => [participant.name, participant]));
-    while (afterIndex < scan.throughIndex) {
+    let cursor = afterIndex;
+    while (cursor < scan.throughIndex) {
         const { value: page } = await artifact.read((facts) => {
-            const page = facts.pendingAudience(afterIndex, scan.throughIndex, 100);
-            return { ...page, groups: page.groups.map((group) => ({ ...group, recipients: group.recipients.filter((recipient) => {
-                        const participant = captured.get(recipient.recipient);
-                        return participant !== undefined && sameJoin(facts, participant);
-                    }) })) };
+            const items = facts.channel.endpoints().filter(endpoint => endpoint.attachment === 'attached' && captured.has(endpoint.participant)).flatMap(endpoint => facts.channel.directed(endpoint.participant, { afterIndex: cursor, throughIndex: scan.throughIndex, unseenOnly: true, currentGeneration: true }, { edge: 'oldest', limit: 100 }).items
+                .filter(() => sameJoin(facts, captured.get(endpoint.participant)))
+                .map(head => enriched(facts, head)));
+            return { items, next: items.at(-1)?.index, done: items.length === 0 };
         });
-        yield page.groups.flatMap((group) => group.recipients.map(({ recipient, route }) => ({
-            index: group.index, at: group.at, actor: group.actor, recipient, route,
-        })));
-        if (!page.hasMore)
+        yield page.items;
+        if (page.done || page.next === undefined)
             break;
-        afterIndex = page.groups.at(-1).index;
+        cursor = page.next;
     }
 }
 /** A pass retains only its captured joins; routes and individual receipts are fresh. */
 export function pendingFacts(facts, scan, heads) {
     const joined = new Set(scan.roster.filter((participant) => sameJoin(facts, participant)).map((participant) => participant.name));
     return { pending: heads.filter((head) => joined.has(head.recipient)
-            && pendingHead(facts, head.recipient, head.index) !== undefined) };
+            && pendingHeadAt(facts.channel, head.recipient, head.index) !== undefined) };
 }
-/** Global discovery alone sweeps pendingAudience; exact dispatch uses pendingRecipients. */
+/** Global discovery alone sweeps every endpoint; exact dispatch uses pendingAddresses. */
 export async function collectPending(artifact) {
     const { value: scan } = await artifact.read(capturePendingScan);
     const pending = [];
@@ -99,8 +71,10 @@ export async function collectPending(artifact) {
     const { value } = await artifact.read((facts) => ({ scan, ...pendingFacts(facts, scan, pending) }));
     return value;
 }
-/** A live catch owns every matching notification, independent of its page size. */
-export function leaseOwnsNotification(lease, notification) {
-    return matchesCatchSelection(notification.actor, notification.route === 'bell' ? { kind: 'bell' }
-        : { kind: 'mentions', names: notification.route === 'mention' ? [notification.recipient] : [] }, lease.filter ?? {}, notification.route === 'reply' ? notification.recipient : undefined);
+function sameWakeAddress(left, right) {
+    if (left === undefined || right === undefined || left.kind !== right.kind)
+        return false;
+    const keys = Object.keys(left.address);
+    return keys.length === Object.keys(right.address).length && keys.every(key => left.address[key] === right.address[key]);
 }
+export { formatMessageId };

package/dist/help.js

@@ -89,11 +89,6 @@ const COMMANDS = [
         names: ['doctor'], usage: 'doctor', usesSquare: true, group: 'maintenance',
         summary: 'Validate artifact integrity.',
     },
-    {
-        names: ['migrate'], usage: 'migrate', usesSquare: true, group: 'maintenance',
-        summary: 'Convert a supported older square to the current format in place.',
-        details: ['For the selected .square artifact only. Stop sessions using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'Versions 2–7 migrate explicitly to format 8. Format 7 migration deletes hold/resume activities and their keyed rows, clears replies to those activities, and preserves surviving activity ids with gaps. Format 6 attachment and opaque-owner conversion are preserved; versions 4/5 first gain attached seats, and 4 also gains empty deferrals. Version 1, unrelated or unsupported artifacts refuse without a write. Names whose legacy owner and routes agree may share an owner; ambiguous names stay standing without custody. Rejoin with the same owner after migration to republish discovery. There is no --check, --backup or --force.'],
-    },
 ];
 function definitionFor(command) {
     return COMMANDS.find((item) => item.names.includes(command));
@@ -105,7 +100,7 @@ export function renderGlobalHelp() {
     const groups = [
         { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'listening', 'catch', 'history', 'status', 'done'] },
         { key: 'host', title: 'Prepare and manage:', order: ['build', 'list', 'participants'] },
-        { key: 'maintenance', title: 'Setup:', order: ['install', 'uninstall', 'doctor', 'migrate'] },
+        { key: 'maintenance', title: 'Setup:', order: ['install', 'uninstall', 'doctor'] },
     ];
     const commandLines = groups.flatMap(({ key, title, order }) => [
         title,

package/dist/http-delivery.d.ts

@@ -1,5 +1,5 @@
-import type { WakeRoute } from './model.js';
-import type { WakeOutcome, WakeRequest, WakeTransportPort } from './ports.js';
+import type { WakeRoute } from './channel-values.js';
+import type { WakeOutcome, WakeRequest, WakeTransportPort } from './channel-transport.js';
 export interface HttpWakeTransportOptions {
     fetch?: typeof fetch;
     env?: NodeJS.ProcessEnv;

package/dist/http-delivery.js

@@ -1,4 +1,3 @@
-import { wakePreview } from './delivery.js';
 /** Configuration only: probing never contacts the receiver. */
 function configuration(route, env) {
     if (route.kind !== 'http')
@@ -53,12 +52,11 @@ export class HttpWakeTransport {
         });
         const send = async () => {
             try {
-                const preview = request.artifact === undefined ? undefined
-                    : (await request.artifact.read(facts => wakePreview(facts, request), controller.signal)).value;
+                const preview = request.presentation?.payload;
                 if (preview === undefined)
                     return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
                 const body = JSON.stringify({
-                    location: request.location, participant: request.participant, activity: request.activity, actor: request.actor,
+                    location: request.location, participant: request.participant, message: request.message, actor: request.actor,
                     ...(request.attemptN === undefined ? {} : { attemptN: request.attemptN }), preview,
                 });
                 if (controller.signal.aborted || Date.now() >= deadline)

package/dist/inbox.d.ts

@@ -1,5 +1,6 @@
 import { type Owner, type LocatedSeat, type PendingMembership } from './model.js';
 import type { SquareRead } from './ports.js';
+import { type NativePendingInput } from './delivery.js';
 export interface PendingWaitOptions {
     signal?: AbortSignal;
     /** Local delivery suppression, never persisted as evidence of receipt. */
@@ -8,8 +9,7 @@ export interface PendingWaitOptions {
     skipImmediate?: boolean;
     onChangeArmed?: (armed: boolean) => void;
 }
-export declare function pendingKey(membership: LocatedSeat, actIndex: number): string;
-export declare function pendingAtBoundary(inbox: readonly PendingMembership[]): PendingMembership[];
+export declare function pendingKey(membership: LocatedSeat, messageIndex: number): string;
 /** Revalidate a supplied batch immediately before the boundary's independent claim/send checks. */
 export declare function projectBoundaryEligibility(inbox: readonly PendingMembership[]): Promise<PendingMembership[]>;
 export interface SessionBindingCandidate {
@@ -31,22 +31,14 @@ export interface NativePendingPreview {
     readonly payload: string;
     readonly clipped: boolean;
 }
-export type NativePendingPreviewInput = {
-    readonly location: string;
-    readonly generation: import('./model.js').ActivityId;
-    readonly participant: string;
-    readonly actIndex: number;
-    readonly cancelledThrough?: number;
-    readonly now: number;
-} & ({
-    readonly routeKind: 'claude-native';
-    readonly address: Readonly<Record<string, string>>;
-} | {
-    readonly routeKind: 'opencode-server';
-    readonly address: Readonly<Record<string, string>>;
-});
-/** Current-generation native attention, owned by its exact wake address and catch state. */
-export declare function nativePendingPreview(facts: SquareRead, input: NativePendingPreviewInput): NativePendingPreview | undefined;
+export interface NativePendingSource {
+    readonly text: string;
+    readonly clipped: boolean;
+}
+/** One current eligibility + source projection read; senders use text, ACK coverage uses clipped. */
+export declare function nativePendingSource(facts: SquareRead, input: NativePendingInput): NativePendingSource | undefined;
+/** The sender-facing fixed reminder over the shared source projection. */
+export declare function nativePendingPreview(facts: SquareRead, input: NativePendingInput): NativePendingPreview | undefined;
 export declare function sessionInbox(owner: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<PendingMembership[]>;
 export interface SessionPendingObserver {
     /** Read committed revisions before reusing content; filesystem hints are only for waiting. */

package/dist/inbox.js

@@ -1,35 +1,27 @@
 import { createArtifactPort, observeSquareDeliveryRevision, observeSquareRevision } from './artifact.js';
 import { indexedSquareEntries, observeSquareIndex } from './square-index.js';
 import { canonicalPath } from './canonical-path.js';
-import { formatActivityId, parseActivityId } from './square-core.js';
+import { formatMessageId } from './message.js';
 import { freshWatchLease, WATCH_STALE_MS } from './runtime.js';
-import { pendingHead, pendingHeads, leaseOwnsNotification } from './delivery.js';
+import { nativePendingHead, pendingHeads } from './delivery.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
-import { attentionBodyIsClipped, renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
-export function pendingKey(membership, actIndex) {
-    return membership.location + '\0' + membership.seat.participant.toLocaleLowerCase() + '\0' + actIndex;
-}
-export function pendingAtBoundary(inbox) {
-    return inbox.map((membership) => {
-        const lease = membership.catchLease;
-        if (lease === undefined)
-            return membership;
-        return { ...membership, notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.seat.participant })) };
-    }).filter((membership) => membership.notifications.length > 0);
+import { projectMessageNotification, renderSquareReminder } from './attention-presentation.js';
+export function pendingKey(membership, messageIndex) {
+    return membership.location + '\0' + membership.seat.participant.toLocaleLowerCase() + '\0' + messageIndex;
 }
 function eligibleNotifications(facts, membership, now = Date.now()) {
     const seat = facts.seat(membership.seat.participant);
     if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== membership.seat.generation
         || seat.owner !== membership.seat.owner)
         return { notifications: [] };
-    const cancelledThrough = facts.cancelledThrough(seat.participant, seat.generation);
+    const cancelledThrough = facts.channel.cancelledThrough(seat.participant, seat.generation);
     let expiry = Infinity;
     const notifications = membership.notifications.filter(notification => {
-        if (cancelledThrough !== undefined && notification.actIndex <= cancelledThrough
-            || facts.deliveryEvidence(seat.participant, seat.generation, formatActivityId(notification.actIndex))
+        if (cancelledThrough !== undefined && notification.messageIndex <= cancelledThrough
+            || facts.deliveryEvidence(seat.participant, seat.generation, formatMessageId(notification.messageIndex))
                 .some(row => row.outcome !== 'failed' && row.outcome !== 'released'))
             return false;
-        const deferredUntil = deliveryDeferralExpiry(facts, seat, notification.actIndex, now);
+        const deferredUntil = deliveryDeferralExpiry(facts.channel, seat, notification.messageIndex, now);
         if (deferredUntil === undefined)
             return true;
         expiry = Math.min(expiry, deferredUntil);
@@ -40,7 +32,7 @@ function eligibleNotifications(facts, membership, now = Date.now()) {
 /** Revalidate a supplied batch immediately before the boundary's independent claim/send checks. */
 export async function projectBoundaryEligibility(inbox) {
     const grouped = new Map();
-    for (const membership of pendingAtBoundary(inbox)) {
+    for (const membership of inbox.filter(candidate => candidate.notifications.length > 0)) {
         const entries = grouped.get(membership.location) ?? [];
         entries.push(membership);
         grouped.set(membership.location, entries);
@@ -88,9 +80,10 @@ function groupCandidates(candidates) {
 }
 function locatedSeats(facts, location, seats) {
     return seats.flatMap(seat => {
-        const index = parseActivityId(seat.generation);
+        const participant = facts.participant(seat.participant);
+        const index = participant?.lastJoinIndex;
         const joined = index === undefined ? undefined : facts.activity(index);
-        return joined?.kind !== 'join' ? [] : [{ location, seat, joinedAt: joined.at }];
+        return joined?.kind === 'join' ? [{ location, seat, joinedAt: joined.at }] : [{ location, seat, joinedAt: 0 }];
     });
 }
 /** Lifecycle reads resolve seats and join times, never pending activity bodies. */
@@ -120,7 +113,7 @@ export async function sessionInboxCounts(input, signal) {
         const artifact = createArtifactPort(location, undefined, signal);
         try {
             rows.push(...(await artifact.read(facts => locatedSeats(facts, location, owners.flatMap(owner => facts.seatsForOwner(owner).filter(seat => seat.attachment === 'attached'))).map(({ seat }) => ({
-                name: seat.participant, squarePath: location, pending: facts.directedCount(seat.participant, { unseenOnly: true }),
+                name: seat.participant, squarePath: location, pending: facts.directedCount(seat.participant, { unseenOnly: true, currentGeneration: true }),
             })), signal)).value);
         }
         catch (error) {
@@ -147,19 +140,24 @@ async function projectPending(candidates, cache, signal) {
                 let cached = cache?.get(location);
                 if (cached?.coordinate !== coordinate || cached.version !== header.revision) {
                     cached = { coordinate, version: header.revision, value: locatedSeats(facts, location, seats).map(membership => {
-                            const heads = pendingHeads(facts, membership.seat.participant);
-                            const routes = new Map(heads.map(head => [head.index, head.route]));
-                            return { ...membership, notifications: facts.activities(heads.map(head => head.index)).flatMap(item => item.kind === 'say'
-                                    ? [{ actIndex: item.index, actor: item.actor, at: item.at, body: item.body ?? '(structured activity)',
-                                            route: routes.get(item.index), ...(item.delivery === undefined ? {} : { delivery: item.delivery }) }]
-                                    : []) };
+                            const heads = pendingHeads(facts, membership.seat.participant, Date.now(), false);
+                            const messages = new Map(facts.channel.messages(heads.map(head => head.index)).map(item => [item.index, item]));
+                            return { ...membership, notifications: heads.flatMap(head => {
+                                    const item = messages.get(head.index);
+                                    if (item === undefined)
+                                        return [];
+                                    return [{ messageIndex: item.index, ...(head.activityIndex === undefined ? {} : { actIndex: head.activityIndex }),
+                                            actor: item.from, at: item.at, body: item.body, ...(item.preview === undefined ? {} : { preview: item.preview }), ...(head.route === undefined ? {} : { route: head.route }) }];
+                                }) };
                         }) };
                 }
                 // Cache conversation content, never leases or delivery eligibility: evidence can change
                 // without a conversation revision and must not force body hydration or self-wake retries.
                 return { cached, pending: cached.value.map(membership => {
                         const catchLease = freshWatchLease(facts, membership.seat.participant);
-                        return { ...membership, ...eligibleNotifications(facts, membership),
+                        // Cached conversation content, but claim coverage and deferrals are re-read on every projection.
+                        const observed = { ...membership, notifications: membership.notifications.filter(note => !facts.channel.suppressed(membership.seat.participant, membership.seat.generation, note.messageIndex, Date.now())) };
+                        return { ...observed, ...eligibleNotifications(facts, observed),
                             ...(catchLease === undefined ? {} : { catchLease }) };
                     }) };
             }, signal);
@@ -178,30 +176,23 @@ async function projectPending(candidates, cache, signal) {
     }
     return pending;
 }
-function sameWakeAddress(address, kind, requested) {
-    if (address?.kind !== kind || Object.keys(address.address).length !== Object.keys(requested).length)
-        return false;
-    return Object.entries(requested).every(([key, value]) => address.address[key] === value);
-}
-/** Current-generation native attention, owned by its exact wake address and catch state. */
-export function nativePendingPreview(facts, input) {
-    const seat = facts.seat(input.participant);
-    if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== input.generation
-        || !sameWakeAddress(seat.wakeAddress, input.routeKind, input.address))
+/** One current eligibility + source projection read; senders use text, ACK coverage uses clipped. */
+export function nativePendingSource(facts, input) {
+    const head = nativePendingHead(facts, input);
+    if (head === undefined)
         return undefined;
-    const cancelledThrough = facts.cancelledThrough(seat.participant, seat.generation);
-    if (input.actIndex <= Math.max(input.cancelledThrough ?? -1, cancelledThrough ?? -1))
+    const item = facts.channel.message(input.index);
+    if (item === undefined)
         return undefined;
-    const head = pendingHead(facts, seat.participant, input.actIndex);
-    const lease = freshWatchLease(facts, input.participant, input.now);
-    if (!head || (lease !== undefined && leaseOwnsNotification(lease, head)))
-        return undefined;
-    const item = facts.activity(input.actIndex);
-    if (item?.kind !== 'say' || deliveryDeferralExpiry(facts, seat, input.actIndex, input.now) !== undefined)
-        return undefined;
-    return { payload: renderSquareReminder([renderAttentionPreview({ squarePath: input.location, recipient: input.participant, actIndex: item.index,
-                actor: item.actor, route: head.route, body: item.body ?? '(structured activity)', delivery: item.delivery })], [item.delivery]),
-        clipped: attentionBodyIsClipped(item.body ?? '(structured activity)', item.delivery) };
+    const projected = projectMessageNotification({ squarePath: input.location, recipient: input.participant,
+        actor: item.from, body: item.body, ...(item.preview === undefined ? {} : { preview: item.preview }),
+        ...(head.activityIndex === undefined || head.route === undefined ? {} : { agora: { actIndex: head.activityIndex, route: head.route } }) });
+    return { text: projected.text, clipped: projected.clipped };
+}
+/** The sender-facing fixed reminder over the shared source projection. */
+export function nativePendingPreview(facts, input) {
+    const source = nativePendingSource(facts, input);
+    return source === undefined ? undefined : { payload: renderSquareReminder([source.text]), clipped: source.clipped };
 }
 export async function sessionInbox(owner, env = process.env, signal) {
     return projectPending(await projectSessionCandidates({ owner, env }), undefined, signal);
@@ -252,9 +243,9 @@ export async function observeSessionPending(owner, suppliedEnv = process.env) {
         });
     }
     function eligibleInbox(inbox, excludeKeys) {
-        const eligible = pendingAtBoundary(inbox);
+        const eligible = inbox.filter(membership => membership.notifications.length > 0);
         return excludeKeys === undefined ? eligible : eligible.flatMap((membership) => {
-            const notifications = membership.notifications.filter((notification) => !excludeKeys.has(pendingKey(membership, notification.actIndex)));
+            const notifications = membership.notifications.filter((notification) => !excludeKeys.has(pendingKey(membership, notification.messageIndex)));
             return notifications.length === 0 ? [] : [{ ...membership, notifications }];
         });
     }
@@ -320,7 +311,7 @@ export async function observeSessionPending(owner, suppliedEnv = process.env) {
                     }
                     const inbox = await currentInbox(candidates, signal);
                     const pending = eligibleInbox(inbox, options.excludeKeys);
-                    const eligibleKeys = JSON.stringify(pending.flatMap((membership) => membership.notifications.map((note) => pendingKey(membership, note.actIndex))).sort());
+                    const eligibleKeys = JSON.stringify(pending.flatMap((membership) => membership.notifications.map((note) => pendingKey(membership, note.messageIndex))).sort());
                     if (previousEligible !== undefined && previousEligible !== eligibleKeys)
                         canReturn = true;
                     previousEligible = eligibleKeys;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Square, squareLocation, squareClock, createSquareResourceOwner, discover, inbox, diagnoseSquare, migrateSquare } from './square-api.js';
+export { Square, squareLocation, squareClock, createSquareResourceOwner, discover, inbox, diagnoseSquare } from './square-api.js';
 export { SquareError, ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { selectOwnSeat, requireOwner, localUserOwner, harnessOwner, decodeHarnessOwner } from './square-api.js';
 export type { WakeTransportPort, WakeRequest, WakeOutcome } from './ports.js';

package/dist/index.js

@@ -1,3 +1,3 @@
-export { Square, squareLocation, squareClock, createSquareResourceOwner, discover, inbox, diagnoseSquare, migrateSquare } from './square-api.js';
+export { Square, squareLocation, squareClock, createSquareResourceOwner, discover, inbox, diagnoseSquare } from './square-api.js';
 export { SquareError, ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { selectOwnSeat, requireOwner, localUserOwner, harnessOwner, decodeHarnessOwner } from './square-api.js';

package/dist/mcp.d.ts

@@ -1,10 +1,11 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type Owner } from './square-api.js';
 import type { SquareAtInput } from './square-facade.js';
+import type { WakeAddress } from './model.js';
 /** The server owns its artifact connection lifetime, so callers cannot lend one. */
 export interface SquareMcpOptions extends Omit<SquareAtInput, 'resources'> {
     readonly owner?: Owner;
-    readonly wakeAddress?: import('./model.js').WakeAddress;
+    readonly wakeAddress?: WakeAddress;
 }
 export type SquareMcpServer = McpServer;
 export declare function createSquareMcpServer(options: SquareMcpOptions): SquareMcpServer;

package/dist/mcp.js

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, SquareExpressDrafts, squareToolsEnabled, squareToolFailure, squareToolFailureText } from './square-tools.js';
+import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, createSquareToolRunner, squareToolsEnabled } from './square-tools.js';
 import { operationEnv } from './participant-identity.js';
 import { codexWakeAddress } from './codex-address.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
@@ -12,7 +12,7 @@ export function createSquareMcpServer(options) {
     const baseEnv = { ...(resourceOptions.env ?? process.env) };
     const toolsEnabled = squareToolsEnabled(baseEnv);
     const resources = createSquareResourceOwner();
-    const drafts = new SquareExpressDrafts();
+    const invoke = createSquareToolRunner();
     // Calls to the configured square borrow one server-owned connection.
     const inFlight = new Set();
     const server = new McpServer({ name: 'square', version: SQUARE_IDENTITY.packageVersion }, {
@@ -21,77 +21,47 @@ export function createSquareMcpServer(options) {
     if (toolsEnabled)
         for (const tool of SQUARE_TOOLS) {
             server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, (args, extra) => {
-                const call = (async () => {
-                    let square;
-                    let toolArgs = args;
-                    let owner;
-                    let draftToken;
-                    let expressAttempted = false;
-                    try {
-                        const threadId = extra._meta?.threadId;
-                        const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
-                        // Claude's plugin endpoint requires the mod's call-local coordinate, never startup identity.
-                        const claude = baseEnv.SQUARE_CLAUDE_MCP_CONTEXT === '1'
-                            ? await readClaudeMcpCall(extra._meta?.['claudecode/toolUseId'], baseEnv)
-                            : undefined;
-                        owner = claude !== undefined
-                            ? harnessOwner({ channel: 'claude-code', session: claude.sessionId, ...(claude.agentId === undefined ? {} : { agent: claude.agentId }) })
-                            : typeof threadId === 'string' && threadId.trim()
-                                ? harnessOwner({ channel: 'codex', session: threadId })
-                                : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
-                                    ? harnessOwner({ channel: 'opencode', session: opencodeSessionId })
-                                    : configuredOwner;
-                        if (tool.name === 'express') {
-                            const resolved = drafts.resolve(toolArgs, owner);
-                            toolArgs = resolved.args;
-                            draftToken = resolved.token;
-                        }
-                        const { location } = toolArgs;
-                        const env = claude !== undefined
-                            ? { ...operationEnv('claude', claude.sessionId, baseEnv),
-                                // Preserve Claude's session + child flag semantics; an agent loop ID is not a session ID.
-                                CLAUDE_CODE_CHILD_SESSION: claude.agentId === undefined ? '' : '1' }
-                            : typeof threadId === 'string' && threadId.trim()
-                                ? operationEnv('codex', threadId, baseEnv)
-                                : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
-                                    ? operationEnv('opencode', opencodeSessionId, baseEnv)
-                                    : baseEnv;
-                        square = await Square.at({
+                const call = invoke(tool, args, { signal: extra.signal }, async () => {
+                    const threadId = extra._meta?.threadId;
+                    const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
+                    // Claude's plugin endpoint requires the mod's call-local coordinate, never startup identity.
+                    const claude = baseEnv.SQUARE_CLAUDE_MCP_CONTEXT === '1'
+                        ? await readClaudeMcpCall(extra._meta?.['claudecode/toolUseId'], baseEnv)
+                        : undefined;
+                    const owner = claude !== undefined
+                        ? harnessOwner({ channel: 'claude-code', session: claude.sessionId, ...(claude.agentId === undefined ? {} : { agent: claude.agentId }) })
+                        : typeof threadId === 'string' && threadId.trim()
+                            ? harnessOwner({ channel: 'codex', session: threadId })
+                            : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
+                                ? harnessOwner({ channel: 'opencode', session: opencodeSessionId })
+                                : configuredOwner;
+                    const env = claude !== undefined
+                        ? { ...operationEnv('claude', claude.sessionId, baseEnv),
+                            // An agent loop ID is not a session ID.
+                            CLAUDE_CODE_CHILD_SESSION: claude.agentId === undefined ? '' : '1' }
+                        : typeof threadId === 'string' && threadId.trim()
+                            ? operationEnv('codex', threadId, baseEnv)
+                            : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
+                                ? operationEnv('opencode', opencodeSessionId, baseEnv)
+                                : baseEnv;
+                    const callWake = wakeAddress !== undefined && (owner === configuredOwner
+                        || wakeAddress.kind === 'paseo' && wakeAddress.address.agentId === baseEnv.PASEO_AGENT_ID
+                        || wakeAddress.kind === 'claude-native' && wakeAddress.address.sessionId === claude?.sessionId
+                        || wakeAddress.kind === 'opencode-server' && wakeAddress.address.sessionId === opencodeSessionId)
+                        ? wakeAddress : undefined;
+                    return {
+                        identity: { owner, wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
+                                ? codexWakeAddress(threadId, env) : callWake },
+                        open: (location, control) => Square.at({
                             ...resourceOptions, env, cwd: claude?.cwd ?? resourceOptions.cwd,
                             path: location ?? options.path,
-                            // The server owner is bound to its configured square; overrides close after each call.
+                            // Overrides and Claude calls own their connections.
                             resources: location === undefined && claude === undefined ? resources : undefined,
-                        }, { signal: extra.signal });
-                        const callWake = wakeAddress !== undefined && (owner === configuredOwner
-                            || wakeAddress.kind === 'paseo' && wakeAddress.address.agentId === baseEnv.PASEO_AGENT_ID
-                            || wakeAddress.kind === 'claude-native' && wakeAddress.address.sessionId === claude?.sessionId
-                            || wakeAddress.kind === 'opencode-server' && wakeAddress.address.sessionId === opencodeSessionId)
-                            ? wakeAddress : undefined;
-                        let text;
-                        try {
-                            expressAttempted = tool.name === 'express';
-                            text = await tool.run(square, toolArgs, { signal: extra.signal }, {
-                                owner, wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
-                                    ? codexWakeAddress(threadId, env) : callWake,
-                            });
-                            drafts.consume(draftToken);
-                        }
-                        finally {
-                            await square.close();
-                        }
-                        return { content: [{ type: 'text', text }] };
-                    }
-                    catch (error) {
-                        const failure = squareToolFailure(error, extra.signal);
-                        const participant = toolArgs.as;
-                        const draft = tool.name === 'express' ? drafts.retain(toolArgs, owner, draftToken, failure, expressAttempted) : undefined;
-                        return { isError: true, content: [{ type: 'text', text: squareToolFailureText(failure, {
-                                        location: square?.location ?? options.path,
-                                        participant: typeof participant === 'string' ? participant : undefined,
-                                        draft,
-                                    }) }] };
-                    }
-                })();
+                        }, control),
+                    };
+                }, options.path).then(({ text, isError }) => ({
+                    ...(isError ? { isError } : {}), content: [{ type: 'text', text }],
+                }));
                 inFlight.add(call);
                 return call.finally(() => { inFlight.delete(call); });
             });

package/dist/message.d.ts

@@ -0,0 +1,7 @@
+export type MessageId = `msg/${number}`;
+/** Opaque endpoint custody token, allocated when an endpoint is established. */
+export type EndpointGeneration = string;
+export declare function formatMessageId(index: number): MessageId;
+export declare function parseMessageId(value: string): number | undefined;
+export declare function newEndpointGeneration(): EndpointGeneration;
+export declare function validateEndpointGeneration(value: unknown): EndpointGeneration;