@astrosheep/square 0.3.63 → 0.3.65

package/dist/square-application.js

@@ -3,22 +3,23 @@ import { setTimeout as sleep } from 'node:timers/promises';
 import { SquareError } from './model.js';
 import { validateDoneBody } from './decisions.js';
 import { currentHold, HELD_WAIT_BUDGET_MS } from './runtime.js';
-import { Square, openParticipant } from './square-wiring.js';
+import { Square } from './square-wiring.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { statusPresentation, participantsPresentation } from './views.js';
-import { hostLedgerForEnv, localParticipantName, localSessionIdentities, readParticipantOwner } from './registry.js';
+import { catchUp, express, ignore, listen, listening } from './square-actions.js';
+import { participantHistory, resolveParticipant, statusPresentation, participantsPresentation } from './views.js';
+import { hostLedgerForEnv, localParticipantName, localSessionIdentities, presenceEpoch, readParticipantOwner } from './registry.js';
 function requireLocation(context) {
     const selected = context.squarePath ?? context.env.SQUARE_LOCATION;
     if (selected === undefined || selected.trim() === '')
         throw new SquareError('invalid_args', 'Square application context needs a square location');
     return path.resolve(context.cwd, selected);
 }
-async function requireParticipant(context, squarePath, env = context.env) {
+async function requireParticipant(context, squarePath, hostLedger, env = context.env) {
     const selected = context.participant ?? env.SQUARE_PARTICIPANT_NAME;
     if (selected?.trim())
         return selected;
-    const discovered = await localParticipantName(squarePath, env).catch(() => undefined);
+    const discovered = await localParticipantName(squarePath, hostLedger, env).catch(() => undefined);
     if (discovered !== undefined)
         return discovered;
     throw new SquareError('invalid_args', 'Square application context needs one unambiguous participant name');
@@ -31,25 +32,26 @@ export function createSquareApplication(context) {
     const env = { ...context.env };
     const location = () => requireLocation({ ...context, env });
     const hostLedger = context.hostLedger ?? hostLedgerForEnv(env);
-    const open = () => Square.at({ path: location(), clock: context.clock, env, hostLedger, wakeTransport: context.wakeTransport });
+    const open = (control) => Square.at({ path: location(), clock: context.clock, env, hostLedger, wakeTransport: context.wakeTransport }, control);
     async function existing(operation, control) {
         checkControl(control);
         const squarePath = location();
-        const participantName = await requireParticipant(context, squarePath, env);
-        const facade = await openParticipant({ path: squarePath, clock: context.clock, env, hostLedger, wakeTransport: context.wakeTransport }, participantName);
+        const participantName = await requireParticipant(context, squarePath, hostLedger, env);
+        const square = await openSquare(squarePath, { clock: context.clock, env, hostLedger, wakeTransport: context.wakeTransport }, control);
         try {
+            const { name } = await resolveParticipant(square, participantName, control);
             checkControl(control);
-            return await operation(facade.participant);
+            return await operation(square, name);
         }
         finally {
-            await facade.close();
+            await closeOpenSquare(square);
         }
     }
     async function joined(operation, control) {
         checkControl(control);
-        const square = await open();
+        const square = await open(control);
         try {
-            return await operation(await square.join(await requireParticipant(context, square.location, env), control));
+            return await operation(await square.join(await requireParticipant(context, square.location, hostLedger, env), control));
         }
         finally {
             await square.close();
@@ -59,14 +61,14 @@ export function createSquareApplication(context) {
         async join(options = {}, control = {}) {
             checkControl(control);
             const squarePath = location();
-            const square = await open();
+            const square = await open(control);
             try {
-                const participantName = await requireParticipant(context, squarePath, env);
-                const before = await square.snapshot();
+                const participantName = await requireParticipant(context, squarePath, hostLedger, env);
+                const before = await square.snapshot(control);
                 const standing = before.participants.some((item) => item.name.toLocaleLowerCase() === participantName.toLocaleLowerCase() && item.state === 'joined');
                 const identity = localSessionIdentities(env)[0];
-                const owner = standing ? await readParticipantOwner(squarePath, participantName, env).catch(() => undefined) : undefined;
-                const reconnect = standing && identity !== undefined && owner?.sessionId === identity.sessionId;
+                const owner = standing ? await readParticipantOwner(squarePath, participantName, hostLedger).catch(() => undefined) : undefined;
+                const reconnect = standing && identity !== undefined && owner?.session === identity.sessionId;
                 if (standing && owner !== undefined && identity !== undefined && !options.takeover && !reconnect) {
                     throw new SquareError('already_joined', `✕ ${participantName} already stands here — another session holds the name`, { pending: before.participants.length });
                 }
@@ -88,7 +90,7 @@ export function createSquareApplication(context) {
             while (true) {
                 checkControl(control);
                 try {
-                    const result = await existing((participant) => participant.express(body, options, control), control);
+                    const result = await existing((square, name) => express(square, name, body, options, control), control);
                     return { ...result, waited };
                 }
                 catch (error) {
@@ -111,7 +113,7 @@ export function createSquareApplication(context) {
                     }
                     else {
                         const waitStarted = Date.now();
-                        const square = await openSquare(location(), { clock: context.clock, env, hostLedger, signal: control.signal });
+                        const square = await openSquare(location(), { clock: context.clock, env, hostLedger }, control);
                         try {
                             const snapshot = await square.artifact.read(control.signal);
                             if (currentHold(snapshot.state.acts).active)
@@ -125,12 +127,12 @@ export function createSquareApplication(context) {
                 }
             }
         },
-        catch(options, control) { return existing((participant) => participant.catch(options, control), control); },
+        catch(options, control) { return existing((square, name) => catchUp(square, name, options, undefined, control), control); },
         async history(query, control) {
             checkControl(control);
             if (context.participant !== undefined || env.SQUARE_PARTICIPANT_NAME !== undefined)
-                return existing((participant) => participant.history(query, control), control);
-            const square = await open();
+                return existing((square, name) => participantHistory(square, name, query, control), control);
+            const square = await open(control);
             try {
                 checkControl(control);
                 return await square.history(query, control);
@@ -139,21 +141,21 @@ export function createSquareApplication(context) {
                 await square.close();
             }
         },
-        listen(target, control) { return existing((participant) => participant.listen(target, control), control); },
-        ignore(target, control) { return existing((participant) => participant.ignore(target, control), control); },
-        listening(control) { return existing((participant) => participant.listening(control), control); },
+        listen(target, control) { return existing((square, name) => listen(square, name, target, control), control); },
+        ignore(target, control) { return existing((square, name) => ignore(square, name, target, control), control); },
+        listening(control) { return existing((square, name) => listening(square, name, control), control); },
         hold(reason, control) { return joined((participant) => participant.hold(reason, control), control); },
         resume(control) { return joined((participant) => participant.resume(control), control); },
         async done(body, control) {
             validateDoneBody(body);
             const squarePath = location();
-            const participantName = await requireParticipant(context, squarePath, env);
+            const participantName = await requireParticipant(context, squarePath, hostLedger, env);
             const identity = localSessionIdentities(env)[0];
-            const owner = identity === undefined ? undefined : await readParticipantOwner(squarePath, participantName, env).catch(() => undefined);
-            if (identity !== undefined && owner?.sessionId === identity.sessionId && owner.epoch > 0) {
-                const square = await open();
+            const owner = identity === undefined ? undefined : await readParticipantOwner(squarePath, participantName, hostLedger).catch(() => undefined);
+            if (identity !== undefined && owner?.session === identity.sessionId && presenceEpoch(owner) > 0) {
+                const square = await open(control);
                 try {
-                    return await square.doneOwnedSession(participantName, body ?? '', owner.epoch, control);
+                    return await square.doneOwnedSession(participantName, body ?? '', presenceEpoch(owner), control);
                 }
                 finally {
                     await square.close();

package/dist/square-core.d.ts

@@ -139,8 +139,11 @@ export declare function audienceIncludes(audience: Audience, name: string): bool
 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;
+/** The author of every landed activity, keyed by index; a reply audience derives from this. */
+export declare function activityAuthors(acts: readonly Act[]): Map<number, Participant>;
 export declare function listeningTo(state: FoldedSquareState, listener: string): string[];
 export declare function isListening(state: FoldedSquareState, listener: string, sender: string): boolean;
+export declare function actorOf(act: Act): Participant | undefined;
 export declare function fold(acts: readonly Act[]): FoldedSquareState;
 /** Replay the activity stream once to fix every say's audience at landing. */
 export declare function replayLandedAudiences(acts: readonly Act[]): LandedAudienceReplay;

package/dist/square-core.js

@@ -60,12 +60,28 @@ export function activeListeners(state, sender) {
 export function isIgnored(state, listener, sender) {
     return (state.ignored.get(nameKey(listener)) ?? []).some((target) => sameName(target, sender));
 }
-function recipientsAtLanding(before, say) {
+/** The author of every landed activity, keyed by index; a reply audience derives from this. */
+export function activityAuthors(acts) {
+    const authors = new Map();
+    for (const act of acts) {
+        const actor = actorOf(act);
+        if (actor === undefined || !('index' in act) || typeof act.index !== 'number')
+            continue;
+        authors.set(act.index, actor);
+    }
+    return authors;
+}
+function recipientsAtLanding(before, say, authors) {
     const audience = audienceOf(say);
-    const mentionTargets = resolveAudience(audience, before.participants.filter((participant) => participant.joined).map((participant) => participant.name));
+    const standing = before.participants.filter((participant) => participant.joined).map((participant) => participant.name);
+    const mentionTargets = resolveAudience(audience, standing);
+    // A reply is directed attention in its own right: it reaches the author of the
+    // replied-to activity under the same standing and ignore rules as a mention.
+    const replyAuthor = say.reply === undefined ? undefined : authors.get(say.reply);
+    const replyTargets = replyAuthor === undefined ? [] : resolveAudience({ kind: 'mentions', names: [replyAuthor] }, standing);
     const listeners = activeListeners(before, say.actor);
     const recipients = [];
-    for (const name of [...mentionTargets, ...listeners]) {
+    for (const name of [...mentionTargets, ...replyTargets, ...listeners]) {
         if (sameName(name, say.actor) || recipients.some((existing) => sameName(existing, name)))
             continue;
         if (audience.kind !== 'bell' && isIgnored(before, name, say.actor))
@@ -80,7 +96,7 @@ export function listeningTo(state, listener) {
 export function isListening(state, listener, sender) {
     return listeningTo(state, listener).some((target) => sameName(target, sender));
 }
-function actorOf(act) {
+export function actorOf(act) {
     if ('actor' in act && typeof act.actor === 'string')
         return act.actor;
     return undefined;
@@ -238,9 +254,10 @@ export function replayLandedAudiences(acts) {
     const byActivity = new Map();
     const byIndex = new Map();
     const lastJoinByKey = new Map();
+    const authors = activityAuthors(acts);
     for (const act of acts) {
         if (act.kind === 'say') {
-            const recipients = recipientsAtLanding(accumulator.state, act);
+            const recipients = recipientsAtLanding(accumulator.state, act, authors);
             byActivity.set(act, recipients);
             const index = 'index' in act ? act.index : undefined;
             if (typeof index === 'number')

package/dist/square-facade.d.ts

@@ -24,6 +24,8 @@ export interface ExpressOptions {
 export interface ExpressResult {
     readonly activity: Activity;
     readonly delivery?: DeliveryResult;
+    /** The replied-to author was not standing when the reply landed, so no notification reached them. */
+    readonly replyAuthorNotHere?: string;
 }
 export interface ListenerChangeResult {
     readonly activity: Activity | null;

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

@@ -1,6 +1,7 @@
 export { observeSquareRevision as observeSquareChanges } from './artifact.js';
 import { type BuildOptions, type HardCap } from './model.js';
 import type { OpenSquare } from './open-square.js';
+import type { OperationControl } from './square-facade.js';
 import type { HostLedgerPort, SquareArtifactPort } from './ports.js';
 /** File-owned artifact creation for the CLI and path-backed public facade. */
 export declare function createSquare(squarePath: string, options: BuildOptions & {
@@ -17,7 +18,7 @@ export interface SquareBuildOptions {
     /** One caller deadline (e.g. a native hook budget) propagated into artifact busy retries. */
     signal?: AbortSignal;
 }
-export declare function openSquare(squarePath: string, options?: Pick<SquareBuildOptions, 'clock' | 'hostLedger' | 'wakeTransport' | 'env' | 'signal'>): Promise<OpenSquare>;
+export declare function openSquare(squarePath: string, options?: Pick<SquareBuildOptions, 'clock' | 'hostLedger' | 'wakeTransport' | 'env' | 'signal'>, control?: OperationControl): Promise<OpenSquare>;
 export declare function probeSquare(squarePath: string): Promise<OpenSquare | undefined>;
 export declare function buildSquare(squarePath: string, options: SquareBuildOptions): Promise<OpenSquare>;
 export declare function buildMemorySquare(options: SquareBuildOptions): OpenSquare;

package/dist/square-file-adapter.js

@@ -1,6 +1,6 @@
 export { observeSquareRevision as observeSquareChanges } from './artifact.js';
 import { hostLedgerRoot } from './host-ledger-root.js';
-import { createSquareState, createSquareSnapshot, probeSquareFile, writeSquareSnapshot, openSquareCell, createMemoryCell, } from './square-storage.js';
+import { createSquareState, createSquareSnapshot, probeSquareFile, writeSquareSnapshot, createFileCell, createMemoryCell, } from './square-storage.js';
 import { InternalSquareError, SquareError, } from './model.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 /** File-owned artifact creation for the CLI and path-backed public facade. */
@@ -24,12 +24,12 @@ function validateBuildOptions(options) {
         throw new SquareError('invalid_args', 'throttlePerMinute must be a positive integer');
     }
 }
-export async function openSquare(squarePath, options = {}) {
+export async function openSquare(squarePath, options = {}, control) {
     const env = options.env ?? process.env;
     const ledgerRoot = hostLedgerRoot(env);
     const artifact = openSquareArtifact(squarePath, options.signal);
     try {
-        await artifact.read();
+        await artifact.read(control?.signal);
         return {
             artifact,
             clock: options.clock ?? Date.now,
@@ -51,7 +51,7 @@ export async function openSquare(squarePath, options = {}) {
 }
 export async function probeSquare(squarePath) {
     const state = await probeSquareFile(squarePath);
-    return state === undefined ? undefined : { artifact: memoryArtifact(createMemoryCell(state)), clock: Date.now, location: squarePath };
+    return state === undefined ? undefined : { artifact: createMemoryCell(state), clock: Date.now, location: squarePath, hostLedger: createHostLedgerPort({ rootPath: hostLedgerRoot(process.env) }) };
 }
 export async function buildSquare(squarePath, options) {
     validateBuildOptions(options);
@@ -77,12 +77,9 @@ export function buildMemorySquare(options) {
         hardCap: options.hardCap ?? null,
         ...(options.throttlePerMinute === undefined ? {} : { throttlePerMinute: options.throttlePerMinute }),
     }, options.markdown);
-    return { artifact: memoryArtifact(createMemoryCell(squareState)), clock: options.clock ?? Date.now, location: 'memory', hostLedger: options.hostLedger, wakeTransport: options.wakeTransport };
+    return { artifact: createMemoryCell(squareState), clock: options.clock ?? Date.now, location: 'memory', hostLedger: options.hostLedger, wakeTransport: options.wakeTransport };
 }
 /** A projection reads and validates its snapshot once; no preliminary duplicate read. */
 export function openSquareArtifact(squarePath, signal) {
-    return memoryArtifact(openSquareCell(squarePath, signal));
-}
-function memoryArtifact(cell) {
-    return { read: (signal) => cell.read(signal), transact: (fn, signal) => cell.transact(fn, signal), changed: (since, timeout, signal) => cell.changed(since, timeout, signal), close: () => cell.close() };
+    return createFileCell(squarePath, signal);
 }

package/dist/square-projections.d.ts

@@ -1,28 +1,56 @@
 import { type InboxMembership, type SquareState } from './model.js';
 import type { HostLedgerPort, SquareArtifactPort, PresentationEvidenceProjection, PresentationProjection, SessionBindingProjection } from './ports.js';
 import { deriveDeliveryModel } from './delivery.js';
-import type { WakeRoute, WakeRouteKind } from './model.js';
+import { type WakeEligibility } from './wake-eligibility.js';
 /** A fresh blocking catch owns only the notifications admitted by its filter. */
 export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
-export declare function projectSessionBindings(input: {
+/**
+ * One eligibility projection for a freshly read session inbox: a fresh catch lease owns what it
+ * admitted, and a delivered (or clipped) boundary already raised awareness for its activity, so
+ * neither belongs at the next boundary. Ordering, session scoping, suppression outcomes and
+ * ledger errors stay exactly as the boundary callers read them.
+ */
+export declare function projectBoundaryEligibility(input: {
     readonly hostLedger: HostLedgerPort;
     readonly sessionId: string;
+    readonly inbox: readonly InboxMembership[];
+}): Promise<InboxMembership[]>;
+export declare function projectSessionBindings(input: {
+    readonly hostLedger: HostLedgerPort;
+    readonly sessionId?: string;
     readonly location?: string;
     readonly now?: number;
 }): Promise<readonly SessionBindingProjection[]>;
-export declare function sessionIdsFromEnvironment(env?: NodeJS.ProcessEnv): readonly string[];
-export declare function projectLocalParticipantBinding(input: {
-    readonly hostLedger: HostLedgerPort;
-    readonly location: string;
-    readonly participant: string;
-    readonly sessionIds: readonly string[];
-    readonly now?: number;
-}): Promise<SessionBindingProjection | undefined>;
 export declare function projectPresentation(input: {
     readonly artifact: SquareArtifactPort;
     readonly binding: SessionBindingProjection;
     readonly now?: number;
 }): Promise<PresentationProjection>;
+export interface NativePendingPreview {
+    readonly payload: string;
+    readonly clipped: boolean;
+}
+/** The one native pending preview. `epoch` matches exactly, and each harness pins its own address entry. */
+export type NativePendingPreviewInput = {
+    readonly location: string;
+    readonly sessionId: string;
+    readonly participant: string;
+    readonly actIndex: number;
+    readonly epoch?: number;
+    readonly cancelledThrough?: number;
+    readonly now: number;
+} & ({
+    readonly routeKind: 'claude-native';
+    readonly address: {
+        readonly endpoint: string;
+    };
+} | {
+    readonly routeKind: 'opencode-server';
+    readonly address: {
+        readonly sessionId: string;
+    };
+});
+export declare function nativePendingPreview(state: SquareState, input: NativePendingPreviewInput): NativePendingPreview | undefined;
 export declare function projectPresentationEvidence(input: {
     readonly hostLedger: HostLedgerPort;
     readonly location?: string;
@@ -33,44 +61,11 @@ export declare function projectPresentationEvidence(input: {
 }): Promise<readonly PresentationEvidenceProjection[]>;
 /** Successful boundary output, including a clipped preview, suppresses awareness wake. */
 export declare function presentationSuppressesWake(evidence: readonly Pick<PresentationEvidenceProjection, 'outcome'>[]): boolean;
-/** The most recently published session owns wake eligibility for its participant. */
-export declare function currentSessionBindings<T extends {
-    readonly participant: string;
-    readonly updatedAt?: number;
-}>(bindings: readonly T[]): T[];
-export interface WakeAttempt {
-    readonly at: number;
-    readonly attention: {
-        readonly squarePath: string;
-        readonly actIndex: number;
-        readonly recipient: string;
-    };
-    readonly routeKind: WakeRouteKind;
-    readonly outcome: 'accepted' | 'unknown' | 'failed';
-    readonly signature?: string;
-    readonly attemptN: number;
-    readonly session?: string;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-}
-export declare function terminalWakeEvidence(attempts: readonly WakeAttempt[]): WakeAttempt | undefined;
-export declare function isWakeRouteAttemptable(route: Pick<WakeRoute, 'kind' | 'updatedAt'>, attempts: readonly WakeAttempt[]): boolean;
-export declare function hasAttemptableWakeRoute(routes: readonly Pick<WakeRoute, 'kind' | 'updatedAt'>[], attempts: readonly WakeAttempt[]): boolean;
-export interface WakeEvidence {
-    readonly delivered: boolean;
-    readonly presented: boolean;
-    readonly attempts: readonly WakeAttempt[];
-    readonly terminal?: WakeAttempt;
-    readonly attemptableRoutes: readonly WakeRoute[];
-}
-export interface WakeEvidenceProjection {
-    evidence(recipient: string, actIndex: number): WakeEvidence;
-}
+/** Read primary evidence once; wake behavior belongs to the pure eligibility projection. */
 export declare function projectWakeEvidenceFromState(input: {
     readonly location: string;
     readonly state: SquareState;
     readonly hostLedger: HostLedgerPort;
     readonly now: number;
     readonly delivery?: ReturnType<typeof deriveDeliveryModel>;
-}): Promise<WakeEvidenceProjection>;
-export declare function wakeIsEligible(evidence: WakeEvidence): boolean;
+}): Promise<WakeEligibility>;

package/dist/square-projections.js

@@ -1,8 +1,10 @@
-import { formatActivityId, parseActivityId } from './square-core.js';
+import { formatActivityId } from './square-core.js';
 import { nameKey } from './model.js';
 import { deriveDeliveryModel, leaseOwnsNotification } from './delivery.js';
 import { freshWatchLease } from './runtime.js';
-import { canonicalRouteLocation } from './routes.js';
+import { attentionBodyIsClipped, renderAttentionPreview } from './attention-presentation.js';
+import { canonicalPath } from './canonical-path.js';
+import { projectWakeEligibility } from './wake-eligibility.js';
 /** A fresh blocking catch owns only the notifications admitted by its filter. */
 export function pendingAtBoundary(inbox) {
     return inbox.map((membership) => {
@@ -12,37 +14,48 @@ export function pendingAtBoundary(inbox) {
         return { ...membership, notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })) };
     }).filter((membership) => membership.notifications.length > 0);
 }
-function bindingProjection(record) {
-    return {
+/**
+ * One eligibility projection for a freshly read session inbox: a fresh catch lease owns what it
+ * admitted, and a delivered (or clipped) boundary already raised awareness for its activity, so
+ * neither belongs at the next boundary. Ordering, session scoping, suppression outcomes and
+ * ledger errors stay exactly as the boundary callers read them.
+ */
+export async function projectBoundaryEligibility(input) {
+    const memberships = pendingAtBoundary([...input.inbox]);
+    if (memberships.length === 0)
+        return [];
+    const evidence = await projectPresentationEvidence({ hostLedger: input.hostLedger, sessionId: input.sessionId });
+    const presented = new Map();
+    for (const row of evidence) {
+        if (row.outcome !== 'presented' && row.outcome !== 'clipped')
+            continue;
+        const key = JSON.stringify([row.location, nameKey(row.participant)]);
+        let activities = presented.get(key);
+        if (activities === undefined)
+            presented.set(key, activities = new Set());
+        activities.add(row.activity);
+    }
+    const pending = [];
+    for (const membership of memberships) {
+        const key = JSON.stringify([await canonicalPath(membership.squarePath), nameKey(membership.name)]);
+        const activities = presented.get(key);
+        const notifications = membership.notifications.filter((notification) => !activities?.has(formatActivityId(notification.actIndex)));
+        if (notifications.length > 0)
+            pending.push({ ...membership, notifications });
+    }
+    return pending;
+}
+export async function projectSessionBindings(input) {
+    const rows = await input.hostLedger.listPresence({ location: input.location, session: input.sessionId, now: input.now });
+    return rows.map((record) => ({
         location: record.location,
         participant: record.participant,
         sessionId: record.session,
         channel: record.channel,
-        ...(record.route === undefined ? {} : {
-            route: {
-                location: record.location,
-                participant: record.participant,
-                sessionId: record.session,
-                channel: record.channel,
-                kind: record.route.kind,
-                address: { ...record.route.address },
-                updatedAt: record.updatedAt ?? 0,
-            },
-        }),
+        ...(record.epoch === undefined ? {} : { epoch: record.epoch }),
+        ...(record.cancelledThrough === undefined ? {} : { cancelledThrough: record.cancelledThrough }),
         updatedAt: record.updatedAt ?? 0,
-    };
-}
-export async function projectSessionBindings(input) {
-    const rows = await input.hostLedger.listPresence({ location: input.location, session: input.sessionId, now: input.now });
-    return rows.map(bindingProjection);
-}
-export function sessionIdsFromEnvironment(env = process.env) {
-    return [env.CLAUDE_CODE_SESSION_ID, env.CODEX_THREAD_ID, env.OPENCODE_SESSION_ID, env.PI_SESSION_ID, env.PASEO_AGENT_ID]
-        .map((value) => value?.trim()).filter((value) => Boolean(value));
-}
-export async function projectLocalParticipantBinding(input) {
-    const bindings = (await Promise.all(input.sessionIds.map((sessionId) => projectSessionBindings({ hostLedger: input.hostLedger, location: input.location, sessionId, now: input.now })))).flat();
-    return bindings.find((binding) => binding.participant.toLocaleLowerCase() === input.participant.toLocaleLowerCase());
+    }));
 }
 export async function projectPresentation(input) {
     const { state } = await input.artifact.read();
@@ -55,6 +68,18 @@ export async function projectPresentation(input) {
     const lease = freshWatchLease(state, known, input.now ?? Date.now());
     return { binding, joined: true, notifications, ...(lease === undefined ? {} : { catchLease: lease }) };
 }
+export function nativePendingPreview(state, input) {
+    const route = state.routes?.find((candidate) => candidate.kind === input.routeKind && candidate.sessionId === input.sessionId
+        && candidate.epoch === input.epoch && nameKey(candidate.participant) === nameKey(input.participant)
+        && (input.routeKind === 'claude-native' ? candidate.address.endpoint === input.address.endpoint : candidate.address.sessionId === input.address.sessionId));
+    if (!route || input.actIndex <= (input.cancelledThrough ?? -1))
+        return undefined;
+    const notification = deriveDeliveryModel(state).pendingFor(input.participant).find((entry) => entry.item.index === input.actIndex);
+    const lease = freshWatchLease(state, input.participant, input.now);
+    if (!notification || (lease !== undefined && leaseOwnsNotification(lease, { ...notification.item, recipient: input.participant, route: notification.route })))
+        return undefined;
+    return { payload: renderAttentionPreview({ squarePath: input.location, recipient: input.participant, actIndex: input.actIndex, actor: notification.item.actor, route: notification.route, body: notification.item.body }), clipped: attentionBodyIsClipped(notification.item.body) };
+}
 export async function projectPresentationEvidence(input) {
     const rows = await input.hostLedger.listEvidence({ kind: 'presentation', location: input.location, participant: input.participant, session: input.sessionId, activity: input.activity, now: input.now });
     return rows.map((row) => ({ location: row.location, participant: row.participant, sessionId: row.session, activity: row.activity, outcome: row.outcome, ...(row.at === undefined ? {} : { at: row.at }) }));
@@ -63,52 +88,13 @@ export async function projectPresentationEvidence(input) {
 export function presentationSuppressesWake(evidence) {
     return evidence.some((row) => row.outcome === 'clipped' || row.outcome === 'presented');
 }
-/** The most recently published session owns wake eligibility for its participant. */
-export function currentSessionBindings(bindings) {
-    const latest = new Map();
-    for (const binding of bindings) {
-        const participant = nameKey(binding.participant);
-        latest.set(participant, Math.max(latest.get(participant) ?? Number.NEGATIVE_INFINITY, binding.updatedAt ?? 0));
-    }
-    return bindings.filter((binding) => (binding.updatedAt ?? 0) === latest.get(nameKey(binding.participant)));
-}
-export function terminalWakeEvidence(attempts) { return attempts.findLast((attempt) => attempt.outcome === 'accepted'); }
-export function isWakeRouteAttemptable(route, attempts) {
-    if (terminalWakeEvidence(attempts) !== undefined)
-        return false;
-    if (attempts.some((attempt) => attempt.routeKind === route.kind && attempt.outcome === 'unknown'))
-        return false;
-    return true;
-}
-export function hasAttemptableWakeRoute(routes, attempts) { return routes.some((route) => isWakeRouteAttemptable(route, attempts)); }
+/** Read primary evidence once; wake behavior belongs to the pure eligibility projection. */
 export async function projectWakeEvidenceFromState(input) {
-    const canonicalLocation = await canonicalRouteLocation(input.location);
+    const canonicalLocation = await canonicalPath(input.location);
     const delivery = input.delivery ?? deriveDeliveryModel(input.state);
-    const bindings = (input.state.routes ?? [])
-        .filter((route) => route.location === canonicalLocation || route.location === input.location)
-        .map((route) => ({ location: route.location, participant: route.participant, sessionId: route.sessionId, channel: route.channel, route: { ...route, address: { ...route.address } }, updatedAt: route.updatedAt }));
-    const wakeRecords = await input.hostLedger.listEvidence({ location: canonicalLocation, kind: 'wake', now: input.now });
-    const attemptsByBinding = new Map();
-    for (const record of wakeRecords) {
-        const actIndex = parseActivityId(record.activity);
-        if (actIndex === undefined || record.routeKind === undefined || typeof record.attemptN !== 'number')
-            continue;
-        const attempt = { attention: { squarePath: record.location, recipient: record.participant, actIndex }, outcome: record.outcome, at: record.at ?? input.now, routeKind: record.routeKind, attemptN: record.attemptN, ...(record.signature === undefined ? {} : { signature: record.signature }), ...(record.session === undefined ? {} : { session: record.session }), ...(record.message === undefined ? {} : { message: record.message }), ...(record.diagnostic === undefined ? {} : { diagnostic: record.diagnostic }) };
-        const key = JSON.stringify([nameKey(record.participant), actIndex, record.session]);
-        const existing = attemptsByBinding.get(key) ?? [];
-        existing.push(attempt);
-        attemptsByBinding.set(key, existing);
-    }
-    const presentedRows = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: canonicalLocation, now: input.now });
-    return {
-        evidence(recipient, actIndex) {
-            const recipientBindings = currentSessionBindings(bindings.filter((binding) => nameKey(binding.participant) === nameKey(recipient)));
-            const routes = recipientBindings.flatMap((binding) => binding.route === undefined ? [] : [binding.route]);
-            const attempts = recipientBindings.flatMap((binding) => attemptsByBinding.get(JSON.stringify([nameKey(recipient), actIndex, binding.sessionId])) ?? []);
-            const terminal = terminalWakeEvidence(attempts);
-            const presented = presentedRows.some((row) => row.activity === formatActivityId(actIndex) && row.participant.toLocaleLowerCase() === recipient.toLocaleLowerCase() && recipientBindings.some((binding) => binding.sessionId === row.sessionId) && presentationSuppressesWake([row]));
-            return { delivered: delivery.isSeen(recipient, actIndex), presented, attempts, ...(terminal === undefined ? {} : { terminal }), attemptableRoutes: terminal === undefined ? routes.filter((route) => isWakeRouteAttemptable(route, attempts)) : [] };
-        },
-    };
+    const owners = await input.hostLedger.listPresence({ location: canonicalLocation, now: input.now });
+    const evidence = await input.hostLedger.listEvidence({ location: canonicalLocation, now: input.now });
+    const wakeRecords = evidence.filter((row) => row.kind === 'wake');
+    const presentations = evidence.filter((row) => row.kind === 'presentation').map((row) => ({ location: row.location, participant: row.participant, sessionId: row.session, activity: row.activity, outcome: row.outcome, ...(row.at === undefined ? {} : { at: row.at }) }));
+    return projectWakeEligibility({ state: input.state, location: canonicalLocation, owners, wakeRecords, presentations, now: input.now, delivery });
 }
-export function wakeIsEligible(evidence) { return !evidence.delivered && !evidence.presented && evidence.terminal === undefined && evidence.attemptableRoutes.length > 0; }

package/dist/square-state.js

@@ -25,9 +25,6 @@ function isNonblankString(value) {
 function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
-function validateObservation(value) {
-    return isObject(value) && hasExactKeys(value, ['state', 'at']) && value.state === 'seen' && isFiniteNumber(value.at);
-}
 function validateWatchLease(value) {
     if (!isObject(value) || !hasExactKeys(value, ['leaseId', 'heartbeatAt', 'expiresAt'], ['filter'])
         || !isNonblankString(value.leaseId) || !isFiniteNumber(value.heartbeatAt)
@@ -46,7 +43,7 @@ function validateRuntime(value) {
     return isObject(value) && hasExactKeys(value, ['nextActIndex', 'observations', 'leases'])
         && isNonNegativeInteger(value.nextActIndex)
         && validateRecord(value.observations, (candidate) => isObject(candidate)
-            && Object.entries(candidate).every(([id, observation]) => parseActivityId(id) !== undefined && validateObservation(observation)))
+            && Object.entries(candidate).every(([id, observation]) => parseActivityId(id) !== undefined && isObject(observation) && hasExactKeys(observation, ['state', 'at']) && observation.state === 'seen' && isFiniteNumber(observation.at)))
         && validateRecord(value.leases, validateWatchLease);
 }
 function validateAssignedRuntimeReferences(runtime) {

package/dist/square-storage.d.ts

@@ -1,17 +1,14 @@
 import { createSquareState, diagnoseSquareFile as diagnoseArtifactFile } from './artifact.js';
 import type { SquareState } from './model.js';
-import type { StateCell } from './state-cell.js';
+import type { SquareArtifactPort } from './ports.js';
 export { createSquareState };
-export declare function readSquareFile(squarePath: string): Promise<SquareState>;
 export declare function probeSquareFile(squarePath: string): Promise<SquareState | undefined>;
 export declare function diagnoseSquareFile(squarePath: string): ReturnType<typeof diagnoseArtifactFile>;
 /** Test-helper snapshot replacement backed by one SQLite artifact. */
 export declare function writeSquareSnapshot(squarePath: string, squareState: SquareState): Promise<void>;
 /** Race-safe non-force creation for the file adapter. */
 export declare function createSquareSnapshot(squarePath: string, squareState: SquareState): Promise<boolean>;
-/** In-process cell for fast behavior tests and embedded consumers. */
-export declare function createMemoryCell(initial: SquareState): StateCell;
-/** SQLite-backed cell. Revisions are read from the authoritative database, not file metadata. */
-export declare function createFileCell(squarePath: string, externalSignal?: AbortSignal): StateCell;
-/** Consumer-facing file cell factory; keeps SQLite framing behind this module. */
-export declare function openSquareCell(squarePath: string, signal?: AbortSignal): StateCell;
+/** In-process artifact for fast behavior tests and embedded consumers. */
+export declare function createMemoryCell(initial: SquareState): SquareArtifactPort;
+/** SQLite-backed artifact. Revisions are read from the authoritative database, not file metadata. */
+export declare function createFileCell(squarePath: string, externalSignal?: AbortSignal): SquareArtifactPort;