@astrosheep/square 0.3.69 → 0.3.71

package/dist/open-square.d.ts

@@ -1,5 +1,6 @@
 import type { HostLedgerPort, SquareArtifactPort, WakeTransportPort } from './ports.js';
-/** Private binding assembled by storage and consumed by the four concerns. */
+import type { OperationControl } from './square-facade.js';
+/** Host-bound resource: artifact, captured environment, clock, ledger and transport. */
 export interface OpenSquare {
     readonly artifact: SquareArtifactPort;
     readonly clock: () => number;
@@ -8,5 +9,18 @@ export interface OpenSquare {
     readonly wakeTransport?: WakeTransportPort;
     readonly env?: NodeJS.ProcessEnv;
 }
-/** Package-private lifecycle boundary for bound squares. */
+export interface SquareBuildOptions {
+    markdown: string;
+    hardCap?: number | null;
+    throttlePerMinute?: number;
+    clock?: () => number;
+    hostLedger?: HostLedgerPort;
+    wakeTransport?: WakeTransportPort;
+    env?: NodeJS.ProcessEnv;
+    /** One caller deadline propagated into artifact busy retries. */
+    signal?: AbortSignal;
+}
+export declare function openSquare(squarePath: string, options?: Pick<SquareBuildOptions, 'clock' | 'hostLedger' | 'wakeTransport' | 'env' | 'signal'>, control?: OperationControl): Promise<OpenSquare>;
+export declare function buildSquare(squarePath: string, options: SquareBuildOptions): Promise<OpenSquare>;
+export declare function buildMemorySquare(options: SquareBuildOptions): OpenSquare;
 export declare function closeOpenSquare(square: OpenSquare): Promise<void>;

package/dist/open-square.js

@@ -1,4 +1,43 @@
-/** Package-private lifecycle boundary for bound squares. */
+import { createArtifactPort, createSquare, prepareSquareBuild } from './artifact.js';
+import { InternalSquareError, SquareError } from './model.js';
+import { hostLedgerRoot } from './host-ledger-root.js';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
+export async function openSquare(squarePath, options = {}, control) {
+    const env = { ...(options.env ?? process.env) };
+    const artifact = createArtifactPort(squarePath, undefined, options.signal);
+    try {
+        await artifact.read(facts => facts.header(), control?.signal);
+        return {
+            artifact, clock: options.clock ?? Date.now, location: squarePath, env,
+            hostLedger: options.hostLedger ?? createHostLedgerPort({ rootPath: hostLedgerRoot(env) }),
+            wakeTransport: options.wakeTransport,
+        };
+    }
+    catch (error) {
+        await artifact.close();
+        if (error instanceof InternalSquareError && error.code === 'not_found')
+            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
+        throw error;
+    }
+}
+export async function buildSquare(squarePath, options) {
+    try {
+        await createSquare(squarePath, { ...options, force: false }, options.markdown, options.signal);
+    }
+    catch (error) {
+        if (error instanceof InternalSquareError && error.code === 'conflict')
+            throw new SquareError('io', `Cannot build over an existing square at ${squarePath}`);
+        throw error;
+    }
+    return openSquare(squarePath, { ...options, signal: undefined });
+}
+export function buildMemorySquare(options) {
+    return {
+        artifact: createArtifactPort(':memory:', prepareSquareBuild(options, options.markdown)),
+        clock: options.clock ?? Date.now, location: 'memory',
+        hostLedger: options.hostLedger, wakeTransport: options.wakeTransport,
+    };
+}
 export function closeOpenSquare(square) {
     return square.artifact.close();
 }

package/dist/perception-projection.d.ts

@@ -1,15 +1,6 @@
-import { type LandedAudienceReplay, type Perception } from './square-core.js';
-import { type SquareState, type StoredAct } from './model.js';
-/**
- * The small, state-only perception surface shared by catch and delivery.
- * Notification planning deliberately remains outside this projection.
- */
-export interface PerceptionProjection {
-    directedTo(activity: StoredAct, name: string): boolean;
-    perceive(activity: StoredAct, name: string): Perception;
-    cursorFor(name: string): number;
-    isSeen(name: string, index: number): boolean;
-    readonly replayedActivityCount: number;
-}
-/** Build perception over one audience replay of a SquareState snapshot. */
-export declare function derivePerceptionProjection(state: SquareState, landed?: LandedAudienceReplay): PerceptionProjection;
+import type { Perception } from './square-core.js';
+import { type StoredAct } from './model.js';
+import type { SquareRead } from './ports.js';
+export declare function directedTo(facts: SquareRead, activity: StoredAct, name: string): boolean;
+/** Audience is settled at landing, never reconstructed from a partial history. */
+export declare function perceiveActivity(facts: SquareRead, activity: StoredAct, name: string): Perception;

package/dist/perception-projection.js

@@ -1,28 +1,8 @@
-import { formatActivityId, replayLandedAudiences } from './square-core.js';
 import { sameName } from './model.js';
-import { readCursor } from './runtime.js';
-/** Build perception over one audience replay of a SquareState snapshot. */
-export function derivePerceptionProjection(state, landed = replayLandedAudiences(state.acts)) {
-    function canonicalName(name) {
-        return landed.resolveParticipant(name) ?? name;
-    }
-    function directedTo(activity, name) {
-        return activity.kind === 'say' && landed.includes(activity, name);
-    }
-    function perceive(activity, name) {
-        if (activity.kind !== 'say' || sameName(activity.actor, name))
-            return 'full';
-        return directedTo(activity, name) ? 'full' : 'presence';
-    }
-    function isSeen(name, index) {
-        const recipient = canonicalName(name);
-        return state.runtime.observations?.[recipient]?.[formatActivityId(index)]?.state === 'seen';
-    }
-    return {
-        directedTo,
-        perceive,
-        cursorFor: (name) => readCursor(state, name, landed),
-        isSeen,
-        replayedActivityCount: landed.replayedActivityCount,
-    };
+export function directedTo(facts, activity, name) {
+    return activity.kind === 'say' && facts.directedAt(name, activity.index) !== undefined;
+}
+/** Audience is settled at landing, never reconstructed from a partial history. */
+export function perceiveActivity(facts, activity, name) {
+    return activity.kind !== 'say' || sameName(activity.actor, name) || directedTo(facts, activity, name) ? 'full' : 'presence';
 }

package/dist/{opencode-delivery.d.ts → plugins/opencode/delivery.d.ts}

@@ -1,4 +1,4 @@
-import { type OpenCodeNativeSession } from './packages/agent-delivery/src/opencode-native.js';
+import { type OpenCodeNativeSession } from '../../packages/agent-delivery/src/opencode-native.js';
 export interface OpenCodeContextMessage {
     readonly id?: string;
     readonly role: string;

package/dist/{opencode-delivery.js → plugins/opencode/delivery.js}

@@ -1,20 +1,20 @@
-import { nameKey } from './model.js';
-import { observeSessionPending, sessionInbox } from './inbox.js';
-import { hostLedgerForEnv } from './registry.js';
-import { openSquare } from './square-file-adapter.js';
-import { closeOpenSquare } from './open-square.js';
-import { nativePendingPreview, presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
-import { presentPending } from './presentation-operations.js';
-import { deliverPending } from './delivery-operations.js';
-import { createWakeTransport } from './notifications.js';
-import { publishWakeRoute } from './routes.js';
-import { formatActivityId, parseActivityId } from './square-core.js';
-import { createNativeInputId, sendNativeText } from './packages/agent-delivery/src/opencode-native.js';
+import { nameKey } from '../../model.js';
+import { nativePendingPreview, observeSessionPending, sessionInbox } from '../../inbox.js';
+import { hostLedgerForEnv } from '../../registry.js';
+import { openSquare } from '../../open-square.js';
+import { closeOpenSquare } from '../../open-square.js';
+import { presentationSuppressesWake, projectPresentationEvidence } from '../../square-projections.js';
+import { presentPending } from '../../presentation-operations.js';
+import { deliverPending } from '../../delivery-operations.js';
+import { createWakeTransport } from '../../notifications.js';
+import { publishWakeRoute } from '../../routes.js';
+import { formatActivityId, parseActivityId } from '../../square-core.js';
+import { createNativeInputId, sendNativeText } from '../../packages/agent-delivery/src/opencode-native.js';
 const routeKind = 'opencode-server';
 const key = (location, participant, index) => `${location}\0${nameKey(participant)}\0${index}`;
 /** The one native pending preview: the audience/catch/epoch fence before send and inside presentation. */
-function preview(state, owner, index) {
-    return nativePendingPreview(state, { location: owner.location, routeKind, sessionId: owner.session, participant: owner.participant, actIndex: index, epoch: owner.epoch, address: { sessionId: owner.session }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+function preview(facts, owner, index) {
+    return nativePendingPreview(facts, { location: owner.location, routeKind, sessionId: owner.session, participant: owner.participant, actIndex: index, epoch: owner.epoch, address: { sessionId: owner.session }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
 }
 function createOpenCodeWakeTransport(target, env, lifetime) {
     const ledger = hostLedgerForEnv(env);
@@ -36,14 +36,14 @@ function createOpenCodeWakeTransport(target, env, lifetime) {
                     return undefined;
                 const square = await openSquare(owner.location, { hostLedger: ledger, env, signal });
                 try {
-                    const prepared = preview((await square.artifact.read(signal)).state, owner, index);
+                    const { value: prepared } = await square.artifact.read((facts) => preview(facts, owner, index), signal);
                     if (!prepared)
                         return undefined;
                     const row = { location: owner.location, participant: owner.participant, session: target.sessionId,
                         activity: request.activity, kind: 'wake', outcome: 'dispatching', routeKind, attemptN: request.attemptN, claimToken: request.claimToken,
                         nativeDelivery: { harness: 'opencode', epoch: owner.epoch ?? 0, inputId: createNativeInputId(), payload: prepared.payload } };
                     if (!await ledger.prepareNativeWake(row) || !await (beforeSend?.() ?? Promise.resolve(true)) || signal.aborted
-                        || preview((await square.artifact.read(signal)).state, owner, index)?.payload !== prepared.payload)
+                        || (await square.artifact.read((facts) => preview(facts, owner, index)?.payload, signal)).value !== prepared.payload)
                         return undefined;
                     return { sending: sendNativeText(target, prepared.payload, { inputId: row.nativeDelivery.inputId, delivery: 'steer',
                             timeoutMs: Math.max(1, deadline - Date.now()), signal }) };
@@ -82,7 +82,7 @@ export async function observeOpenCodeContext(sessionId, messages, env, signal) {
                 continue;
             const square = await openSquare(row.location, { hostLedger: ledger, env, signal });
             try {
-                const prepared = preview((await square.artifact.read(signal)).state, owner, index);
+                const { value: prepared } = await square.artifact.read((facts) => preview(facts, owner, index), signal);
                 if (!prepared || prepared.payload !== row.nativeDelivery.payload)
                     continue;
                 const prior = await projectPresentationEvidence({ hostLedger: ledger, location: row.location, participant: row.participant, sessionId, activity: row.activity });
@@ -90,7 +90,7 @@ export async function observeOpenCodeContext(sessionId, messages, env, signal) {
                     continue;
                 await presentPending({ artifact: square.artifact, hostLedger: ledger, location: row.location, participant: row.participant, session: sessionId,
                     activity: row.activity, sink: { present() { } }, markSeen: !prepared.clipped, signal,
-                    current: (state) => !signal.aborted && preview(state, owner, index)?.payload === row.nativeDelivery.payload });
+                    current: (facts) => !signal.aborted && preview(facts, owner, index)?.payload === row.nativeDelivery.payload });
             }
             finally {
                 await closeOpenSquare(square);

package/dist/{opencode.d.ts → plugins/opencode/index.d.ts}

@@ -1,5 +1,5 @@
-import { type OpenCodeSessionCapability } from './packages/agent-delivery/src/opencode-native.js';
-import { type OpenCodeContextMessage } from './opencode-delivery.js';
+import { type OpenCodeSessionCapability } from '../../packages/agent-delivery/src/opencode-native.js';
+import { type OpenCodeContextMessage } from './delivery.js';
 interface OpenCodePluginContext {
     readonly app: {
         readonly version: string;

package/dist/{opencode.js → plugins/opencode/index.js}

@@ -1,11 +1,11 @@
-import { automaticSessionStart, operationEnv } from './automatic-session.js';
-import { hostLedgerForEnv } from './registry.js';
-import { canonicalPath } from './canonical-path.js';
-import { openSquare } from './square-file-adapter.js';
-import { closeOpenSquare } from './open-square.js';
-import { Square } from './square-wiring.js';
-import { connectNative } from './packages/agent-delivery/src/opencode-native.js';
-import { observeOpenCodeContext, publishOpenCodeRoutes, receiveOpenCodePending } from './opencode-delivery.js';
+import { automaticSessionStart, operationEnv } from '../../automatic-session.js';
+import { hostLedgerForEnv } from '../../registry.js';
+import { canonicalPath } from '../../canonical-path.js';
+import { openSquare } from '../../open-square.js';
+import { closeOpenSquare } from '../../open-square.js';
+import { Square } from '../../square-application.js';
+import { connectNative } from '../../packages/agent-delivery/src/opencode-native.js';
+import { observeOpenCodeContext, publishOpenCodeRoutes, receiveOpenCodePending } from './delivery.js';
 /** Actual OpenCode 2.0.20 server plugin. Harness identity belongs to ctx, never process.env. */
 export default {
     id: 'square',
@@ -81,7 +81,7 @@ export default {
                 for (const owner of (await ledger.listPresence({ session: sessionId })).filter((binding) => binding.channel === 'opencode')) {
                     const square = await openSquare(owner.location, { hostLedger: ledger, env, signal: lifetime.signal });
                     try {
-                        await ledger.suppressPresence(owner, (await square.artifact.read(lifetime.signal)).state.runtime.nextActIndex - 1);
+                        await ledger.suppressPresence(owner, (await square.artifact.read((facts) => facts.header().nextActIndex - 1, lifetime.signal)).value);
                     }
                     finally {
                         await closeOpenSquare(square);

package/dist/ports.d.ts

@@ -1,16 +1,161 @@
-import type { InboxNotification, SquareState, StoredAct, WakeRoute, WatchLease } from './model.js';
+import type { Act, HardCap, InboxNotification, StoredAct, WakeRoute, WakeRouteKind, WatchLease } from './model.js';
 export type { ClaimResult, EvidenceClaim, EvidenceRelease, EvidenceGc, EvidenceLookup, EvidenceRecord, HostLedgerPort, PresenceKey, PresenceLookup, PresenceRecord, PresenceClaimResult, PresenceChannel, PresenceResult, } from './host-ledger.js';
 import type { HostLedgerPort } from './host-ledger.js';
-/** Atomic artifact access. Never exposes framing, compression, locks, or storage schema. */
+export type ActivityIndex = number;
+export interface SquareHeader {
+    readonly revision: number;
+    readonly nextActIndex: number;
+    readonly lastActIndex: number;
+    readonly hardCap: HardCap;
+    readonly throttlePerMinute?: number;
+    readonly preamble: readonly string[];
+    readonly warmup: readonly string[];
+}
+export interface ParticipantFact {
+    readonly name: string;
+    readonly firstIndex: number;
+    readonly joined: boolean;
+    readonly done: boolean;
+    readonly sayCount: number;
+    readonly lastActiveAt?: number;
+    readonly lastJoinIndex?: number;
+}
+export interface AttentionFact {
+    readonly listener: string;
+    readonly target: string;
+    readonly kind: 'listen' | 'ignore';
+    readonly sinceIndex: number;
+}
+export interface ActivityHead {
+    readonly index: ActivityIndex;
+    readonly at: number;
+    readonly kind: StoredAct['kind'];
+    readonly actor?: string;
+    readonly reach?: 'bell';
+    readonly reply?: ActivityIndex;
+}
+export interface ActivityFilter {
+    readonly afterIndex?: number;
+    readonly beforeIndex?: number;
+    readonly throughIndex?: number;
+    readonly indexes?: readonly ActivityIndex[];
+    readonly kinds?: readonly StoredAct['kind'][];
+    readonly actors?: readonly string[];
+    readonly actorMatch?: 'identity' | 'exact';
+    readonly actorRequired?: true;
+    readonly afterAt?: number;
+}
+export interface IndexPage {
+    readonly edge: 'oldest' | 'newest';
+    readonly limit: number;
+}
+export interface FactPage<T> {
+    readonly items: readonly T[];
+    readonly hasMore: boolean;
+}
+export interface DirectedFilter {
+    readonly afterIndex?: number;
+    readonly beforeIndex?: number;
+    readonly throughIndex?: number;
+    readonly unseenOnly?: true;
+    readonly senders?: readonly string[];
+    readonly attentionOnly?: true;
+}
+export interface DirectedHead {
+    readonly index: ActivityIndex;
+    readonly at: number;
+    readonly actor: string;
+    readonly recipient: string;
+    readonly route: 'mention' | 'reply' | 'attention' | 'bell';
+}
+export interface LandedRecipient {
+    readonly recipient: string;
+    readonly route: DirectedHead['route'];
+}
+export interface ReceiptFacts {
+    readonly latestAt?: number;
+    readonly latestActorActivityIndex?: number;
+}
+export interface ReceiptAssignment {
+    readonly owner: string;
+    readonly index: ActivityIndex;
+}
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export interface RouteFact {
+    readonly location: string;
+    readonly participant: string;
+    readonly sessionId: string;
+    readonly channel: string;
+    readonly kind: WakeRouteKind;
+    readonly address: Readonly<Record<string, string>>;
+    readonly updatedAt: number;
+    readonly epoch?: JsonValue;
+    readonly extra: Readonly<Record<string, JsonValue>>;
+}
+/** Domain facts exist only during a synchronous artifact callback. Values are detached. */
+export interface SquareRead {
+    header(): SquareHeader;
+    participant(requestedName: string): ParticipantFact | undefined;
+    roster(): readonly ParticipantFact[];
+    attention(listener: string): readonly AttentionFact[];
+    incomingAttention(sender: string): readonly AttentionFact[];
+    hold(): {
+        readonly active: boolean;
+        readonly at?: number;
+        readonly reason?: string;
+        readonly actor?: string;
+    };
+    activity(index: ActivityIndex): StoredAct | undefined;
+    activityHeads(filter: ActivityFilter, page: IndexPage): FactPage<ActivityHead>;
+    activities(indexes: readonly ActivityIndex[]): readonly StoredAct[];
+    activityCount(filter: ActivityFilter): number;
+    contextIndexes(centers: readonly ActivityIndex[], before: number, after: number): readonly ActivityIndex[];
+    sayOrdinals(indexes: readonly ActivityIndex[]): Readonly<Record<number, number>>;
+    recentSayTimes(afterExclusive: number, takeLatest: number, actor?: string, bellOnly?: true): readonly number[];
+    audience(index: ActivityIndex): readonly LandedRecipient[];
+    directed(recipient: string, filter: DirectedFilter, page: IndexPage): FactPage<DirectedHead>;
+    directedAt(recipient: string, index: ActivityIndex): DirectedHead | undefined;
+    directedCount(recipient: string, filter: DirectedFilter): number;
+    pendingAudience(afterExclusive: number, throughInclusive: number, activityLimit: number): {
+        readonly groups: readonly {
+            readonly index: ActivityIndex;
+            readonly at: number;
+            readonly actor: string;
+            readonly recipients: readonly LandedRecipient[];
+        }[];
+        readonly hasMore: boolean;
+    };
+    receipt(requestedName: string, index: ActivityIndex): {
+        readonly at: number;
+    } | undefined;
+    receiptFacts(requestedName: string, afterIndex: number): ReceiptFacts;
+    receiptAssignments(): readonly ReceiptAssignment[];
+    lease(requestedName: string): WatchLease | undefined;
+    routes(): readonly RouteFact[];
+}
+export interface SquareWrite extends SquareRead {
+    land(activity: Act & {
+        readonly at: number;
+    }): StoredAct;
+    markSeen(requestedName: string, indexes: readonly ActivityIndex[], at: number): number;
+    putLease(requestedName: string, lease: WatchLease): boolean;
+    removeLease(requestedName: string, expectedLeaseId: string): boolean;
+    replaceRoutes(routes: readonly RouteFact[]): boolean;
+}
+export interface SquareReadResult<R> {
+    readonly value: R;
+    readonly version: number;
+}
+export interface SquareCommitResult<R> extends SquareReadResult<R> {
+    readonly changed: boolean;
+}
+/** Atomic artifact access; no framing, SQL or lazy transaction capability escapes. */
 export interface SquareArtifactPort {
-    read(signal?: AbortSignal): Promise<{
-        state: SquareState;
-        version: number;
-    }>;
-    transact<R>(fn: (state: SquareState, version: number) => {
-        state?: SquareState;
-        result: R;
-    }, signal?: AbortSignal): Promise<R>;
+    read<R>(select: (facts: SquareRead) => R, signal?: AbortSignal): Promise<SquareReadResult<R>>;
+    transact<R>(change: (facts: SquareWrite) => R, signal?: AbortSignal): Promise<SquareCommitResult<R>>;
+    revision(signal?: AbortSignal): Promise<number>;
     changed(sinceVersion: number, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
     close(): Promise<void>;
 }
@@ -121,5 +266,5 @@ export interface PresentPendingInput {
     /** Boundary previews that were clipped remain pending for a later full presentation. */
     readonly markSeen?: boolean;
     /** Receiver-specific fences checked inside the artifact observation transaction. */
-    readonly current?: (state: SquareState) => boolean;
+    readonly current?: (facts: SquareRead) => boolean;
 }

package/dist/presentation-operations.d.ts

@@ -1,3 +1,3 @@
 import type { PresentationResult, PresentPendingInput } from './ports.js';
-/** Present one pending activity; artifact seen remains the authoritative receipt. */
+/** Presentation evidence is not a receipt; only the fenced receipt transaction marks seen. */
 export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;

package/dist/presentation-operations.js

@@ -1,65 +1,56 @@
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { deriveDeliveryModel } from './delivery.js';
-import { recordObservation } from './runtime.js';
-/** Present one pending activity; artifact seen remains the authoritative receipt. */
+import { pendingHead, sameJoin } from './delivery.js';
+/** Presentation evidence is not a receipt; only the fenced receipt transaction marks seen. */
 export async function presentPending(input) {
     const index = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
     if (index === undefined)
         return { presented: false };
-    let before;
-    try {
-        before = await input.artifact.read(input.signal);
-    }
-    catch {
-        return { presented: false };
-    }
-    const delivery = deriveDeliveryModel(before.state);
-    const item = before.state.acts.find((activity) => activity.index === index);
-    if (input.current?.(before.state) === false || item === undefined || delivery.isSeen(input.participant, index) || !delivery.pendingFor(input.participant).some((notification) => notification.item.index === index))
+    const before = await input.artifact.read((facts) => {
+        if (input.current?.(facts) === false || !pendingHead(facts, input.participant, index))
+            return undefined;
+        return { item: facts.activity(index), participant: facts.participant(input.participant) };
+    }, input.signal).catch(() => undefined);
+    if (before?.value === undefined)
         return { presented: false };
+    const { item, participant } = before.value;
+    const current = (facts) => sameJoin(facts, participant) && input.current?.(facts) !== false
+        && pendingHead(facts, participant.name, index) !== undefined;
+    const coordinate = { location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation' };
     let claimToken;
+    const release = async () => {
+        if (claimToken !== undefined)
+            await input.hostLedger.releaseEvidence({ ...coordinate, claimToken });
+    };
     if (input.hostLedger !== undefined && input.session !== undefined) {
-        const claim = await input.hostLedger.claimEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', leaseMs: input.timeoutMs ?? 5000 });
+        const claim = await input.hostLedger.claimEvidence({ ...coordinate, leaseMs: input.timeoutMs ?? 5000 });
         if (claim.status !== 'acquired')
             return { presented: false };
         claimToken = claim.claimToken;
-        let current;
-        try {
-            current = await input.artifact.read(input.signal);
-        }
-        catch {
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken }).catch(() => undefined);
-            return { presented: false };
-        }
-        if (input.current?.(current.state) === false || deriveDeliveryModel(current.state).isSeen(input.participant, index)) {
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken }).catch(() => undefined);
+        const fresh = await input.artifact.read(current, input.signal).catch(() => undefined);
+        if (!fresh?.value) {
+            await release().catch(() => undefined);
             return { presented: false };
         }
-        try {
-            await input.sink.present(item);
-        }
-        catch (error) {
-            await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: 'failed', message: error instanceof Error ? error.message : String(error), claimToken });
-            throw error;
-        }
     }
-    else
+    try {
         await input.sink.present(item);
-    const committed = await input.artifact.transact((state) => {
-        const current = deriveDeliveryModel(state);
-        if (input.current?.(state) === false || current.isSeen(input.participant, index) || !current.pendingFor(input.participant).some((notification) => notification.item.index === index))
-            return { result: false };
-        if (input.markSeen === false)
-            return { result: true };
-        const changed = recordObservation(state, input.participant, index, 'seen', input.now ?? Date.now());
-        return changed ? { state, result: true } : { result: false };
+    }
+    catch (error) {
+        if (claimToken !== undefined)
+            await input.hostLedger.appendEvidence({ ...coordinate, outcome: 'failed', message: error instanceof Error ? error.message : String(error), claimToken });
+        throw error;
+    }
+    const { value: committed } = await input.artifact.transact((facts) => {
+        if (!current(facts))
+            return false;
+        return input.markSeen === false || facts.markSeen(participant.name, [index], input.now ?? Date.now()) > 0;
     }, input.signal);
     if (!committed) {
-        if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== undefined)
-            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken });
+        await release();
         return { presented: false };
     }
-    if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== undefined)
-        await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: input.markSeen === false ? 'clipped' : 'presented', ...(input.markSeen === false ? { message: 'presentation clipped' } : {}), claimToken });
+    if (claimToken !== undefined)
+        await input.hostLedger.appendEvidence({ ...coordinate, outcome: input.markSeen === false ? 'clipped' : 'presented',
+            ...(input.markSeen === false ? { message: 'presentation clipped' } : {}), claimToken });
     return { presented: true, activity: item };
 }

package/dist/presentation.d.ts

@@ -1,7 +1,7 @@
-import { type StoredAct, type SquareState, type PublicAct, type RoomChangeAct } from './model.js';
+import { type StoredAct, type RoomChangeAct } from './model.js';
 export { participantIdentity } from './participant-identity.js';
 import { type Perception } from './square-core.js';
-import type { UnreadActivitySummary, ParticipantStatus } from './decisions.js';
+import type { Activity, UnreadActivitySummary, ParticipantSummary } from './square-facade.js';
 export type WatchStatus = 'stale' | 'empty-now' | 'quorum' | 'capped';
 interface HeaderOptions {
     participantCount?: number;
@@ -23,7 +23,7 @@ interface ActivityLimitOptions extends ParticipantOutputOptions {
 interface ActivityBlockedOptions extends ParticipantOutputOptions {
     retryCommand: string;
     forceCommand: string;
-    activitySummaries: UnreadActivitySummary[];
+    activitySummaries: readonly UnreadActivitySummary[];
     draftPath?: string;
 }
 interface ExpressWaitingOptions {
@@ -44,7 +44,7 @@ interface WatchStatusOptions extends ParticipantOutputOptions {
     status: WatchStatus;
     idleMs?: number;
     presence?: {
-        participants: ParticipantStatus[];
+        participants: readonly ParticipantSummary[];
         now: number;
     };
     showCatchHint?: boolean;
@@ -58,6 +58,7 @@ export declare function formatRefusal(squarePath: string, bodyLines: string[], o
     participantCount?: number;
     held?: boolean;
 }): string;
+export declare function refusalText(error: unknown): string;
 export declare function quoteShell(value: string): string;
 export declare function commandPrefix(squarePath: string): string;
 export declare function participantCommandPrefix(squarePath: string, name: string): string;
@@ -66,44 +67,42 @@ export declare function joinRecoveryCommand(squarePath: string, name: string): s
 /** Taking a name is an explicit recovery choice, never an automatic retry. */
 export declare function takeoverRecoveryLines(squarePath: string, name: string): string[];
 export declare function participantsRecoveryCommand(squarePath: string): string;
-export declare function renderPresenceLines(participants: ParticipantStatus[], now: number, limit?: number): string[];
+export declare function renderPresenceLines(recent: readonly ParticipantSummary[], now: number, limit?: number): string[];
 export declare function expressHintLine(ownActivityCount: number): string | undefined;
 export declare function truncateChars(body: string, maxChars: number): {
     text: string;
     remaining: number;
 };
 export declare function truncateExternalDiagnostic(diagnostic: string): string;
-export declare function renderRoomChangeText(event: RoomChangeAct): string;
+export declare function renderRoomChangeText(event: RoomChangeAct | Activity): string;
 interface RenderedEvent {
     text: string;
     /** The rendered body was cut short by `preview`. */
     bodyClipped: boolean;
 }
-export declare function renderEventCli(event: StoredAct, opts?: {
+export declare function renderEventCli(event: StoredAct | Activity, opts?: {
     now?: number;
     preview?: number;
     actNumber?: number;
     mention?: string;
 }): string;
-export declare function renderAmbientEventFacts(event: StoredAct, viewer: string, opts?: {
+export declare function renderAmbientEventFacts(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
     actNumber?: number;
     mention?: string;
-    squareState?: SquareState;
     perception?: Perception;
 }): RenderedEvent;
-export declare function renderAmbientEvent(event: StoredAct, viewer: string, opts?: {
+export declare function renderAmbientEvent(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
     actNumber?: number;
     mention?: string;
-    squareState?: SquareState;
     perception?: Perception;
 }): string;
-export declare function renderPendingFeed(history: StoredAct[], publicItems: PublicAct[], viewer: string | undefined, squareState: SquareState): string;
+export declare function renderPendingFeed(publicItems: readonly StoredAct[], sayNumbers: Readonly<Record<number, number>>, perceptions: Readonly<Record<number, Perception>>, viewer: string): string;
 export declare function renderActivityBlocked(opts: ActivityBlockedOptions): string;
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export declare function renderActivityUncertain(opts: ParticipantOutputOptions & {
@@ -114,7 +113,7 @@ export declare function renderActivityUncertain(opts: ParticipantOutputOptions &
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
 export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPresenceAnchor(names: readonly string[]): string;
-export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
+export declare function renderGrepActivitiesView(visible: readonly StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
 export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
 export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;
@@ -123,9 +122,3 @@ export declare function renderWatchReplaced(_opts: ParticipantOutputOptions): st
 export declare function renderWatchStatus(opts: WatchStatusOptions): string;
 export declare function renderDoctorClean(): string;
 export declare function renderDoctorUnfixable(reason: string): string;
-export declare function renderWatchOutput(history: StoredAct[], publicItems: PublicAct[], opts: {
-    mention?: string;
-    viewer: string;
-    squareState?: SquareState;
-    perceptions?: ReadonlyMap<number, Perception>;
-}): string;