@astrosheep/square 0.3.62 → 0.3.64

package/dist/host-ledger.d.ts

@@ -1,16 +1,14 @@
 import type { WakeRouteKind } from './model.js';
-export type PresenceChannel = 'claude-code' | 'codex' | 'opencode' | 'pi' | 'paseo' | 'unknown';
+import type { HarnessSessionChannel } from './participant-identity.js';
+export type PresenceChannel = HarnessSessionChannel | 'unknown';
 export interface PresenceRecord {
     readonly location: string;
     readonly participant: string;
     readonly session: string;
     readonly channel: PresenceChannel;
-    readonly route?: {
-        readonly kind: WakeRouteKind;
-        readonly address: Readonly<Record<string, string>>;
-    };
     readonly updatedAt?: number;
     readonly epoch?: number;
+    readonly cancelledThrough?: number;
 }
 export type PresenceKey = Pick<PresenceRecord, 'location' | 'participant' | 'session' | 'channel'>;
 export interface PresenceLookup {
@@ -38,12 +36,24 @@ export type PresenceClaimResult = {
     readonly record: PresenceRecord;
     readonly error: unknown;
 };
+export type NativeDeliveryEvidence = {
+    readonly payload: string;
+    readonly epoch: number;
+} & ({
+    readonly harness: 'claude';
+    readonly endpoint: string;
+} | {
+    readonly harness: 'opencode';
+    readonly inputId: string;
+});
 export interface EvidenceRecord {
+    readonly bindingEpoch?: number;
+    readonly nativeDelivery?: NativeDeliveryEvidence;
     readonly location: string;
     readonly participant: string;
     readonly session: string;
     readonly activity: string;
-    readonly kind: 'wake' | 'presentation';
+    readonly kind: 'wake' | 'presentation' | 'lifecycle';
     readonly outcome: string;
     readonly at?: number;
     readonly expiresAt?: number;
@@ -53,25 +63,33 @@ export interface EvidenceRecord {
     readonly message?: string;
     readonly diagnostic?: unknown;
     readonly claimToken?: string;
+    readonly ownerPid?: number;
+    readonly unknownSource?: 'interrupted' | 'transport';
 }
+/** Presentation and lifecycle claims only: wake attempts are acquired by claimWakeAttempt. */
 export interface EvidenceClaim {
     readonly location: string;
     readonly participant: string;
     readonly session: string;
     readonly activity: string;
-    readonly kind: EvidenceRecord['kind'];
+    readonly kind: 'presentation' | 'lifecycle';
     readonly leaseMs: number;
-    readonly claimToken?: string;
     readonly now?: number;
 }
 /** Release metadata and includeReleased are diagnostic-only; default evidence reads stay behavior-safe. */
-export interface EvidenceRelease extends Omit<EvidenceClaim, 'leaseMs'> {
+export interface EvidenceRelease {
+    readonly location: string;
+    readonly participant: string;
+    readonly session: string;
+    readonly activity: string;
+    readonly kind: EvidenceRecord['kind'];
     readonly claimToken: string;
     readonly routeKind?: WakeRouteKind;
     readonly attemptN?: number;
     readonly signature?: string;
     readonly message?: string;
     readonly diagnostic?: unknown;
+    readonly now?: number;
 }
 export interface EvidenceLookup {
     readonly location?: string;
@@ -91,46 +109,28 @@ export interface WakeAttention {
     readonly actIndex: number;
     readonly recipient: string;
 }
-export interface WakeDispatchLease {
-    readonly leaseId: string;
-    readonly expiresAt: number;
-    readonly phase: 'claimed' | 'dispatching';
-    readonly routeKind?: WakeRouteKind;
-    readonly attemptN?: number;
-    readonly session?: string;
+/** One wake attempt row carries attention-wide exclusion and session-specific history. */
+export interface WakeAttemptClaimInput {
+    readonly attention: WakeAttention;
+    readonly session: string;
+    readonly routeKind: WakeRouteKind;
+    readonly leaseMs: number;
+    readonly now?: number;
 }
-export type WakeDispatchClaim = {
-    readonly type: 'acquired';
-    readonly leaseId: string;
+export type WakeAttemptClaim = {
+    readonly status: 'acquired';
+    readonly claimToken: string;
+    readonly attemptN: number;
+} | {
+    readonly status: 'busy';
+    readonly record: EvidenceRecord;
 } | {
-    readonly type: 'busy';
+    readonly status: 'terminal';
+    readonly record: EvidenceRecord;
 } | {
-    readonly type: 'ambiguous';
-    readonly lease: WakeDispatchLease;
+    readonly status: 'degraded';
+    readonly error: unknown;
 };
-export interface WakeDispatchClaimInput {
-    readonly attention: WakeAttention;
-    readonly leaseId: string;
-    readonly leaseMs: number;
-    readonly session?: string;
-    readonly at?: number;
-}
-export interface WakeDispatchTransitionInput {
-    readonly attention: WakeAttention;
-    readonly leaseId: string;
-    readonly phase: WakeDispatchLease['phase'];
-    readonly leaseMs: number;
-    readonly routeKind?: WakeRouteKind;
-    readonly attemptN?: number;
-    readonly session?: string;
-    readonly at?: number;
-}
-export interface WakeDispatchReleaseInput {
-    readonly attention: WakeAttention;
-    readonly leaseId: string;
-    readonly session?: string;
-    readonly at?: number;
-}
 export interface WakeAttemptLookup {
     readonly attention?: WakeAttention;
     readonly session?: string;
@@ -147,8 +147,10 @@ export type ClaimResult = {
     readonly error: unknown;
 };
 export interface HostLedgerPort {
+    withClaimLock<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
     claimPresence(input: PresenceRecord, signal?: AbortSignal): Promise<PresenceClaimResult>;
     ensurePresence(input: PresenceRecord): Promise<PresenceResult>;
+    suppressPresence(input: PresenceRecord, through: number): Promise<boolean>;
     removePresence(input: PresenceKey): Promise<void>;
     removePresenceIfUnchanged(input: PresenceRecord): Promise<boolean>;
     listPresence(input: PresenceLookup): Promise<readonly PresenceRecord[]>;
@@ -159,11 +161,14 @@ export interface HostLedgerPort {
     }): Promise<void>;
     listEvidence(input: EvidenceLookup): Promise<readonly EvidenceRecord[]>;
     listWakeAttempts(input?: WakeAttemptLookup): Promise<readonly EvidenceRecord[]>;
-    appendWakeAttempt(input: EvidenceRecord & {
+    prepareNativeWake(input: EvidenceRecord & {
         readonly claimToken: string;
-    }): Promise<void>;
-    claimWakeDispatch(input: WakeDispatchClaimInput): Promise<WakeDispatchClaim>;
-    transitionWakeDispatch(input: WakeDispatchTransitionInput): Promise<boolean>;
-    releaseWakeDispatch(input: WakeDispatchReleaseInput): Promise<void>;
+        readonly routeKind: WakeRouteKind;
+        readonly nativeDelivery: NativeDeliveryEvidence;
+    }): Promise<boolean>;
+    confirmWakeAdmission(input: EvidenceRecord & {
+        readonly claimToken: string;
+    }): Promise<boolean>;
+    claimWakeAttempt(input: WakeAttemptClaimInput): Promise<WakeAttemptClaim>;
     gcEvidence(input: EvidenceGc): Promise<void>;
 }

package/dist/inbox.d.ts

@@ -1,5 +1,4 @@
 import { type InboxMembership } from './model.js';
-export declare function hostLedgerForEnv(env: NodeJS.ProcessEnv): import("./host-ledger-file-adapter.js").FileHostLedgerPort;
 export interface PendingWaitOptions {
     signal?: AbortSignal;
     /** Local delivery suppression, never persisted as evidence of receipt. */
@@ -15,5 +14,3 @@ export interface SessionPendingObserver {
 }
 /** Session-scoped projection over process-shared storage change detectors. */
 export declare function observeSessionPending(sessionId: string, suppliedEnv?: NodeJS.ProcessEnv): Promise<SessionPendingObserver>;
-/** Finite one-shot consumers retain their API; Pi owns a long-lived observer instead. */
-export declare function waitForSessionPending(sessionId: string, timeoutMs: number, options?: PendingWaitOptions, env?: NodeJS.ProcessEnv): Promise<InboxMembership[]>;

package/dist/inbox.js

@@ -1,13 +1,8 @@
-import { hostLedgerRoot } from './host-ledger-root.js';
 import { openSquareArtifact, observeSquareChanges } from './square-file-adapter.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-import { canonicalFilePath } from './file-changes.js';
-import { pendingAtBoundary, presentationSuppressesWake, projectPresentation, projectPresentationEvidence, projectSessionBindings } from './square-projections.js';
-import { formatActivityId } from './square-core.js';
+import { hostLedgerForEnv } from './registry.js';
+import { canonicalPath } from './canonical-path.js';
+import { projectBoundaryEligibility, projectPresentation, projectSessionBindings } from './square-projections.js';
 import { WATCH_STALE_MS } from './runtime.js';
-export function hostLedgerForEnv(env) {
-    return createHostLedgerPort({ rootPath: hostLedgerRoot(env) });
-}
 function notificationKey(membership, actIndex) {
     return membership.squarePath + '\0' + membership.name.toLocaleLowerCase() + '\0' + actIndex;
 }
@@ -72,7 +67,7 @@ export async function observeSessionPending(sessionId, suppliedEnv = process.env
                     // Subscribe/capture the ledger BEFORE discovering bindings; a concurrent join cannot fall in a gap.
                     const sources = await Promise.all([capture(ledger.presence, 'presence', signal), capture(ledger.evidence, 'evidence', signal)]);
                     const bindings = await projectSessionBindings({ hostLedger, sessionId });
-                    const paths = new Set(await Promise.all(bindings.map((binding) => canonicalFilePath(binding.location))));
+                    const paths = new Set(await Promise.all(bindings.map((binding) => canonicalPath(binding.location))));
                     for (const [file, observer] of artifacts) {
                         if (!paths.has(file)) {
                             observer.close();
@@ -91,18 +86,16 @@ export async function observeSessionPending(sessionId, suppliedEnv = process.env
                     }
                     sources.push(...await Promise.all([...artifacts.values()].map((observer) => capture(observer, 'artifact', signal))));
                     const inbox = await sessionInbox(sessionId, env, signal);
-                    const pending = [];
-                    for (const membership of pendingAtBoundary(inbox)) {
-                        const evidence = await projectPresentationEvidence({ hostLedger, location: membership.squarePath, participant: membership.name, sessionId });
-                        const notifications = membership.notifications.filter((notification) => !options.excludeKeys?.has(notificationKey(membership, notification.actIndex)) &&
-                            !presentationSuppressesWake(evidence.filter((row) => row.activity === formatActivityId(notification.actIndex))));
-                        if (notifications.length > 0)
-                            pending.push({ ...membership, notifications });
-                    }
-                    const eligible = JSON.stringify(pending.flatMap((membership) => membership.notifications.map((note) => notificationKey(membership, note.actIndex))).sort());
-                    if (previousEligible !== undefined && previousEligible !== eligible)
+                    const eligible = await projectBoundaryEligibility({ hostLedger, sessionId, inbox });
+                    const excludeKeys = options.excludeKeys;
+                    const pending = excludeKeys === undefined ? eligible : eligible.flatMap((membership) => {
+                        const notifications = membership.notifications.filter((notification) => !excludeKeys.has(notificationKey(membership, notification.actIndex)));
+                        return notifications.length === 0 ? [] : [{ ...membership, notifications }];
+                    });
+                    const eligibleKeys = JSON.stringify(pending.flatMap((membership) => membership.notifications.map((note) => notificationKey(membership, note.actIndex))).sort());
+                    if (previousEligible !== undefined && previousEligible !== eligibleKeys)
                         canReturn = true;
-                    previousEligible = eligible;
+                    previousEligible = eligibleKeys;
                     if (signal.aborted)
                         return [];
                     if (canReturn && pending.length > 0)
@@ -167,13 +160,3 @@ export async function observeSessionPending(sessionId, suppliedEnv = process.env
         },
     };
 }
-/** Finite one-shot consumers retain their API; Pi owns a long-lived observer instead. */
-export async function waitForSessionPending(sessionId, timeoutMs, options = {}, env = process.env) {
-    const observer = await observeSessionPending(sessionId, env);
-    try {
-        return await observer.wait(timeoutMs, options);
-    }
-    finally {
-        observer.close();
-    }
-}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { Square } from './square-wiring.js';
 export { createSquareApplication } from './square-application.js';
 export { SquareError } from './model.js';
-export { bindCurrentParticipant, squareAssignedParticipantName, unbindCurrentParticipant } from './registry.js';
+export { squareAssignedParticipantName } from './registry.js';
 export { createDefaultWakeTransport } from './notifications.js';
 export { createHostLedgerPort, FileHostLedgerPort } from './host-ledger-file-adapter.js';
 export type { HostLedgerPort, PresenceRecord, EvidenceRecord } from './host-ledger.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 export { Square } from './square-wiring.js';
 export { createSquareApplication } from './square-application.js';
 export { SquareError } from './model.js';
-export { bindCurrentParticipant, squareAssignedParticipantName, unbindCurrentParticipant } from './registry.js';
+export { squareAssignedParticipantName } from './registry.js';
 export { createDefaultWakeTransport } from './notifications.js';
 export { createHostLedgerPort, FileHostLedgerPort } from './host-ledger-file-adapter.js';

package/dist/list.js

@@ -15,9 +15,6 @@ const CONTEXT_PREVIEW_LINES = 2;
 const PARTICIPANT_PREVIEW_COUNT = 3;
 const DISPLAY_CHARACTER_LIMIT = 160;
 const LIST_SKIP_DIRS = new Set(['.git', 'node_modules', 'dist']);
-function contextLines(lines) {
-    return lines.map((line) => line.trim()).filter(Boolean);
-}
 async function readSquareListItem(filePath, root) {
     let stat;
     try {
@@ -34,7 +31,7 @@ async function readSquareListItem(filePath, root) {
     return {
         path: relative,
         lastActiveAt: stat.mtimeMs,
-        context: contextLines([...projection.context]),
+        context: [...projection.context].map((line) => line.trim()).filter(Boolean),
         participants: [...projection.participants],
         activities: projection.activities,
     };

package/dist/mcp.js

@@ -3,45 +3,23 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod/v4';
 import { SquareError, isSquareError } from './model.js';
 import { createSquareApplication } from './square-application.js';
-const activityIdSchema = { type: 'string', pattern: '^act/(0|[1-9][0-9]*)$' };
-const stringArraySchema = { type: 'array', items: { type: 'string' } };
-function objectSchema(properties, required = []) { return { properties, required }; }
+import { toPublicActivity } from './views.js';
+const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
+const stringArray = z.array(z.string());
 const TOOL_DEFINITIONS = [
-    { name: 'join', description: 'Join the square as the configured participant.', inputSchema: objectSchema({ takeover: { type: 'boolean' } }) },
-    { name: 'express', description: 'Express a message or embodied action in the square.', inputSchema: objectSchema({ body: { type: 'string' }, mentions: stringArraySchema, reach: { type: 'string', enum: ['bell'] }, reply: activityIdSchema, force: { type: 'boolean' }, noWait: { type: 'boolean' } }, ['body']) },
-    { name: 'catch', description: 'Catch and consume activities perceptible to the configured participant.', inputSchema: objectSchema({ id: activityIdSchema, idle: { type: 'number', minimum: 0 }, from: stringArraySchema, mention: { type: 'boolean' }, limit: { type: 'integer', minimum: 1 } }) },
-    { name: 'history', description: 'Read the activity stream using stable activity-id cursors.', inputSchema: objectSchema({ limit: { type: 'integer', minimum: 1 }, order: { type: 'string', enum: ['asc', 'desc'] }, before: activityIdSchema, after: activityIdSchema, grep: { type: 'string' }, fixed: { type: 'string' }, from: stringArraySchema, mention: { type: 'string' } }) },
-    { name: 'listen', description: 'Listen for future activity from a participant.', inputSchema: objectSchema({ target: { type: 'string' } }, ['target']) },
-    { name: 'ignore', description: 'Stop listening for future activity from a participant.', inputSchema: objectSchema({ target: { type: 'string' } }, ['target']) },
-    { name: 'listening', description: 'List participants this participant is listening to.', inputSchema: objectSchema({}) },
-    { name: 'hold', description: 'Raise a hand to hold the square.', inputSchema: objectSchema({ reason: { type: 'string' } }) },
-    { name: 'resume', description: 'Release the current hold.', inputSchema: objectSchema({}) },
-    { name: 'done', description: 'Leave the square without adding a message.', inputSchema: objectSchema({}) },
-    { name: 'status', description: 'Read the public status of the square.', inputSchema: objectSchema({}) },
-    { name: 'participants', description: 'List participants standing in or done with the square.', inputSchema: objectSchema({}) },
+    { name: 'join', description: 'Join the square as the configured participant.', inputSchema: z.object({ takeover: z.boolean().optional() }).strict() },
+    { name: 'express', description: 'Express a message or embodied action in the square.', inputSchema: z.object({ body: z.string(), mentions: stringArray.optional(), reach: z.enum(['bell']).optional(), reply: activityId.optional(), force: z.boolean().optional(), noWait: z.boolean().optional() }).strict() },
+    { name: 'catch', description: 'Catch and consume activities perceptible to the configured participant.', inputSchema: z.object({ id: activityId.optional(), idle: z.number().finite().min(0).optional(), from: stringArray.optional(), mention: z.boolean().optional(), limit: z.number().int().min(1).optional() }).strict() },
+    { name: 'history', description: 'Read the activity stream using stable activity-id cursors.', inputSchema: z.object({ limit: z.number().int().min(1).optional(), order: z.enum(['asc', 'desc']).optional(), before: activityId.optional(), after: activityId.optional(), grep: z.string().optional(), fixed: z.string().optional(), from: stringArray.optional(), mention: z.string().optional() }).strict() },
+    { name: 'listen', description: 'Listen for future activity from a participant.', inputSchema: z.object({ target: z.string() }).strict() },
+    { name: 'ignore', description: 'Stop listening for future activity from a participant.', inputSchema: z.object({ target: z.string() }).strict() },
+    { name: 'listening', description: 'List participants this participant is listening to.', inputSchema: z.object({}).strict() },
+    { name: 'hold', description: 'Raise a hand to hold the square.', inputSchema: z.object({ reason: z.string().optional() }).strict() },
+    { name: 'resume', description: 'Release the current hold.', inputSchema: z.object({}).strict() },
+    { name: 'done', description: 'Leave the square without adding a message.', inputSchema: z.object({}).strict() },
+    { name: 'status', description: 'Read the public status of the square.', inputSchema: z.object({}).strict() },
+    { name: 'participants', description: 'List participants standing in or done with the square.', inputSchema: z.object({}).strict() },
 ];
-function zodInputSchema(schema) {
-    const shape = {};
-    for (const [key, property] of Object.entries(schema.properties)) {
-        let field;
-        if (property.type === 'string' && property.enum !== undefined)
-            field = z.enum(property.enum);
-        else if (property.type === 'string')
-            field = property.pattern === undefined ? z.string() : z.string().regex(new RegExp(property.pattern));
-        else if (property.type === 'boolean')
-            field = z.boolean();
-        else if (property.type === 'number')
-            field = z.number().finite().min(property.minimum ?? -Infinity);
-        else if (property.type === 'integer')
-            field = z.number().int().min(property.minimum ?? -Infinity);
-        else if (property.type === 'array')
-            field = z.array(z.string());
-        else
-            throw new Error(`Unsupported input schema type: ${property.type}`);
-        shape[key] = schema.required.includes(key) ? field : field.optional();
-    }
-    return z.object(shape).strict();
-}
 function isObject(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }
 function publicActivity(activity) { return { ...activity }; }
 function publicResult(name, value) {
@@ -56,13 +34,13 @@ function publicResult(name, value) {
             doneCount: rest.doneCount,
             hold: rest.holdActive ? { by: rest.holdActor, ...(rest.holdReason === undefined ? {} : { reason: rest.holdReason }), ...(rest.holdAt === undefined ? {} : { at: rest.holdAt }) } : null,
             participants: participants.filter((participant) => participant.state !== 'not joined').map((participant) => ({ name: participant.name, state: participant.state, presence: participant.presence, activityCount: participant.activityCount, ...(participant.lastActiveAt === undefined ? {} : { lastActiveAt: participant.lastActiveAt }), unreadActivityCount: participant.unreadActivityCount, pendingMentionCount: participant.pendingMentionCount, listening: participant.listening })),
-            ...(latestAct === undefined ? {} : { latestActivity: publicActivity({ id: `act/${latestAct.index}`, at: latestAct.at, kind: latestAct.kind, actor: latestAct.actor ?? '', ...('body' in latestAct && latestAct.body !== undefined ? { body: latestAct.body } : {}), mentions: 'mentions' in latestAct ? latestAct.mentions ?? [] : [], ...('target' in latestAct ? { target: latestAct.target } : {}), ...(latestAct.kind === 'say' && latestAct.reach !== undefined ? { reach: latestAct.reach } : {}), ...(latestAct.kind === 'say' && latestAct.reply !== undefined ? { reply: `act/${latestAct.reply}` } : {}) }) }),
+            ...(latestAct === undefined ? {} : { latestActivity: publicActivity(toPublicActivity(latestAct)) }),
             now: rest.now,
         };
     }
     if (name === 'express' || name === 'hold' || name === 'resume' || name === 'done') {
         const result = value;
-        return { ...(result.activity === undefined ? {} : { activity: result.activity === null ? null : publicActivity(result.activity) }), ...(result.waited === undefined ? {} : { waited: result.waited }) };
+        return { ...(result.activity === undefined ? {} : { activity: result.activity === null ? null : publicActivity(result.activity) }), ...(result.waited === undefined ? {} : { waited: result.waited }), ...(result.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: result.replyAuthorNotHere }) };
     }
     if (name === 'history')
         return { activities: value };
@@ -98,7 +76,7 @@ export function createSquareMcpServer(options) {
         instructions: 'The catch tool consumes activities. Use history with act/<index> cursors for read-only archive access.',
     });
     for (const tool of TOOL_DEFINITIONS) {
-        server.registerTool(tool.name, { description: tool.description, inputSchema: zodInputSchema(tool.inputSchema) }, async (args, extra) => {
+        server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, async (args, extra) => {
             try {
                 const value = await operation(app, tool.name, args, { signal: extra.signal });
                 const projected = publicResult(tool.name, value);

package/dist/mention-parse.js

@@ -54,14 +54,6 @@ function codeSpanRanges(body) {
     }
     return ranges;
 }
-function codePointBefore(body, index) {
-    if (index <= 0)
-        return undefined;
-    const unit = body.charCodeAt(index - 1);
-    if (unit >= 0xdc00 && unit <= 0xdfff && index >= 2)
-        return String.fromCodePoint(body.codePointAt(index - 2));
-    return String.fromCodePoint(unit);
-}
 export function scanMentionCandidates(body) {
     const spans = codeSpanRanges(body);
     const found = [];
@@ -70,7 +62,9 @@ export function scanMentionCandidates(body) {
         const start = match.index;
         if (spans.some(([from, to]) => start >= from && start < to))
             continue;
-        const previous = codePointBefore(body, start);
+        const unit = start <= 0 ? undefined : body.charCodeAt(start - 1);
+        const previous = unit === undefined ? undefined
+            : unit >= 0xdc00 && unit <= 0xdfff && start >= 2 ? String.fromCodePoint(body.codePointAt(start - 2)) : String.fromCodePoint(unit);
         if (previous !== undefined && BOUNDARY_BLOCKER.test(previous))
             continue;
         const token = match[1];

package/dist/model.d.ts

@@ -1,10 +1,12 @@
 import type { Act, ActivityId } from './square-core.js';
 export { formatActivityId, parseActivityId } from './square-core.js';
 export type { Act, ActivityId, Audience, Reach } from './square-core.js';
-export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "pi-extension", "paseo"];
+export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "paseo"];
 export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
 export declare function isWakeRouteKind(value: unknown): value is WakeRouteKind;
 export interface WakeRoute {
+    /** Ownership generation, when the receiver publishes a fenced route. */
+    epoch?: number;
     location: string;
     participant: string;
     sessionId: string;
@@ -20,6 +22,13 @@ export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reach
 export interface SquareErrorFacts {
     /** Express admission rejected before any activity was committed. */
     activityUnsent?: true;
+    /** Why a name could not be resolved: never in the roster, no longer standing in it, a bell
+     * colliding with a mention, an @name that matches nobody, or an activity catch cannot address. */
+    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'unmatched_mention' | 'not_addressed';
+    /** The activity id a `catch --id` refusal named. */
+    activityId?: string;
+    /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
+    activityExists?: boolean;
     pending?: number;
     holder?: string;
     holdReason?: string;
@@ -62,7 +71,7 @@ export interface WatchLease {
     expiresAt: number;
     filter?: WatchLeaseFilter;
 }
-export type DirectedNotificationRoute = 'mention' | 'attention' | 'bell';
+export type DirectedNotificationRoute = 'mention' | 'reply' | 'attention' | 'bell';
 export interface InboxNotification {
     actIndex: number;
     actor: string;

package/dist/model.js

@@ -1,6 +1,6 @@
 // Shared model and constants for Square.
 export { formatActivityId, parseActivityId } from './square-core.js';
-export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'pi-extension', 'paseo'];
+export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'paseo'];
 export function isWakeRouteKind(value) {
     return typeof value === 'string' && WAKE_ROUTE_KINDS.includes(value);
 }

package/dist/notifications.d.ts

@@ -1,27 +1,16 @@
-import { planActNotifications, type WakeAdapter } from './delivery.js';
-import { type SquareState } from './model.js';
-import { matchesMentionTarget } from './runtime.js';
-import { type ActivityId } from './square-core.js';
+import { type WakeAdapter } from './delivery.js';
 import type { WakeTransportPort } from './ports.js';
 export type { PlannedNotification } from './delivery.js';
-export { planActNotifications, matchesMentionTarget };
-export { notificationMessageId } from './delivery.js';
 export declare const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export declare function wakeGraceMs(env?: NodeJS.ProcessEnv): number;
-export declare function hasDeliveredNotification(squarePath: string, name: string, ref: number | ActivityId): Promise<boolean>;
-export declare function hasAttentionNotification(squarePath: string, name: string, ref: number | ActivityId, env?: NodeJS.ProcessEnv): Promise<boolean>;
-export declare function waitForDeliveredNotification(squarePath: string, name: string, ref: number | ActivityId, opts?: {
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}): Promise<boolean>;
 interface ProcessNotificationOptions {
     adapters?: WakeAdapter[];
     env?: NodeJS.ProcessEnv;
     now?: () => number;
 }
 export declare function defaultWakeAdapters(): Promise<WakeAdapter[]>;
-export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv): Promise<WakeTransportPort>;
-export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number): WakeTransportPort;
+export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv, suppliedAdapters?: readonly WakeAdapter[]): Promise<WakeTransportPort>;
+export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, nativePorts?: Readonly<Partial<Record<import('./model.js').WakeRouteKind, WakeTransportPort>>>): WakeTransportPort;
 export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<import("./ports.js").DeliveryResult>;
 /** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares within one boundary budget. */
 export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedAdapters?: WakeAdapter[], deadline?: number, signal?: AbortSignal): Promise<void>;
@@ -31,7 +20,5 @@ export interface SweepPendingNotificationsOptions {
     limit?: number;
     dispatchCandidate?: (actIndex: number) => void | Promise<void>;
 }
-/** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: import('./model.js').SquareState) => ReturnType<typeof import('./delivery.js').deriveDeliveryModel>): Promise<number[]>;
 /** Select old pending attention at a bounded action boundary for an explicit executor. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;