@astrosheep/square 0.3.95 → 0.3.97

package/dist/artifact.d.ts

@@ -34,7 +34,7 @@ export declare function writeSquareFile(location: string, state: SquareState, si
 /** Explicit test/export projection. Hot callers must use the typed port. */
 export declare function readSquareSnapshot(location: string, signal?: AbortSignal): Promise<SquareSnapshot>;
 export declare function readSquareRevision(location: string, signal?: AbortSignal): Promise<number>;
-export declare function observeSquareRevision(location: string): Promise<import('./file-changes.js').VersionObserver<number | null>>;
 export declare function readSquareDeliveryRevision(location: string, signal?: AbortSignal): Promise<number>;
+export declare function observeSquareRevision(location: string): Promise<import('./file-changes.js').VersionObserver<number | null>>;
 export declare function observeSquareDeliveryRevision(location: string): Promise<import('./file-changes.js').VersionObserver<number | null>>;
 export declare function diagnoseSquareFile(location: string): Promise<DiagnoseResult>;

package/dist/artifact.js

@@ -120,7 +120,7 @@ const readMethods = [
     'header', 'participant', 'roster', 'attention', 'incomingAttention',
     'activity', 'activityHeads', 'activities', 'activityCount', 'contextIndexes', 'sayOrdinals', 'recentSayTimes',
     'audience', 'directed', 'directedAt', 'directedCount', 'pendingAudience',
-    'receipt', 'receiptFacts', 'receiptAssignments', 'lease', 'participantCounts', 'seat', 'seatsForOwner',
+    'receipt', 'receiptFacts', 'lease', 'participantCounts', 'seat', 'seatsForOwner',
     'deliveryEvidence', 'deliveryByToken', 'cancelledThrough', 'deliveryDeferrals',
 ];
 const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'reattachSeat', 'detachSeat', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery', 'putDeliveryDeferral', 'renewDeliveryDeferral', 'releaseDeliveryDeferral'];
@@ -404,26 +404,14 @@ export function readSquareSnapshot(location, signal) {
 export function readSquareRevision(location, signal) {
     return inspectFile(location, db => createSqliteDriver(db).header().revision, signal);
 }
-export function observeSquareRevision(location) {
-    return observeFileVersion(location, 'square-revision', async (file, signal) => {
-        try {
-            return await readSquareRevision(file, signal);
-        }
-        catch (error) {
-            abort(signal);
-            if (error instanceof InternalSquareError && error.code === 'not_found')
-                return null;
-            throw error;
-        }
-    });
-}
 export function readSquareDeliveryRevision(location, signal) {
     return inspectFile(location, db => createSqliteDriver(db).header().deliveryRevision, signal);
 }
-export function observeSquareDeliveryRevision(location) {
-    return observeFileVersion(location, 'square-delivery-revision', async (file, signal) => {
+function observeRevision(location, revision) {
+    const read = revision === 'square-revision' ? readSquareRevision : readSquareDeliveryRevision;
+    return observeFileVersion(location, revision, async (file, signal) => {
         try {
-            return await readSquareDeliveryRevision(file, signal);
+            return await read(file, signal);
         }
         catch (error) {
             abort(signal);
@@ -433,6 +421,12 @@ export function observeSquareDeliveryRevision(location) {
         }
     });
 }
+export function observeSquareRevision(location) {
+    return observeRevision(location, 'square-revision');
+}
+export function observeSquareDeliveryRevision(location) {
+    return observeRevision(location, 'square-delivery-revision');
+}
 export async function diagnoseSquareFile(location) {
     try {
         return { problems: [], ...await inspectFile(await canonicalPath(location), inspectSqlite) };

package/dist/attention-presentation.d.ts

@@ -1,4 +1,4 @@
-import type { DirectedNotificationRoute } from './model.js';
+import type { ActivityDelivery, DirectedNotificationRoute } from './model.js';
 export declare const ATTENTION_BODY_MAX = 200;
 export interface AttentionPreview {
     squarePath: string;
@@ -7,13 +7,14 @@ export interface AttentionPreview {
     actor: string;
     route: DirectedNotificationRoute;
     body: string;
+    delivery?: ActivityDelivery;
 }
-export declare function previewAttentionBody(body: string): string;
-export declare function attentionBodyIsClipped(body: string): boolean;
+export declare function previewAttentionBody(body: string, delivery?: ActivityDelivery): string;
+export declare function attentionBodyIsClipped(body: string, delivery?: ActivityDelivery): boolean;
 export declare function displayAttentionPath(squarePath: string): string;
 export declare function renderAttentionDescription({ actor, route }: Pick<AttentionPreview, 'actor' | 'route'>): string;
 /** Full notification text for human-facing expansion, never the bounded model preview. */
 export declare function renderAttentionFull(attention: AttentionPreview): string;
 /** Shared model-facing envelope; transport correlation and human cards stay outside it. */
-export declare function renderSquareReminder(previews: readonly string[]): string;
+export declare function renderSquareReminder(previews: readonly string[], deliveries?: readonly (ActivityDelivery | undefined)[]): string;
 export declare function renderAttentionPreview(attention: AttentionPreview): string;

package/dist/attention-presentation.js

@@ -1,14 +1,16 @@
 import { homedir } from 'node:os';
 import { formatActivityId } from './square-core.js';
 export const ATTENTION_BODY_MAX = 200;
-export function previewAttentionBody(body) {
-    const compact = body.replace(/\r\n/g, '\n');
-    if (compact.length <= ATTENTION_BODY_MAX)
+export function previewAttentionBody(body, delivery) {
+    const compact = (delivery?.mode === 'direct' ? delivery.preview ?? body : body).replace(/\r\n/g, '\n');
+    if (delivery?.mode === 'direct' || compact.length <= ATTENTION_BODY_MAX)
         return compact;
     return `${compact.slice(0, ATTENTION_BODY_MAX).trimEnd()}…`;
 }
-export function attentionBodyIsClipped(body) {
-    return body.replace(/\r\n/g, '\n').length > ATTENTION_BODY_MAX;
+export function attentionBodyIsClipped(body, delivery) {
+    return delivery?.mode === 'direct'
+        ? delivery.preview !== undefined
+        : body.replace(/\r\n/g, '\n').length > ATTENTION_BODY_MAX;
 }
 export function displayAttentionPath(squarePath) {
     return squarePath.startsWith(homedir())
@@ -25,7 +27,7 @@ export function renderAttentionDescription({ actor, route }) {
 }
 /** Full notification text for human-facing expansion, never the bounded model preview. */
 export function renderAttentionFull(attention) {
-    return renderAttentionBlock(attention, attention.body);
+    return attention.delivery?.mode === 'direct' ? renderDirectBlock(attention) : renderAttentionBlock(attention, attention.body);
 }
 /** Attribute values keep their quotes; the stored body and the human card stay unescaped. */
 function escapeAttribute(value) {
@@ -49,14 +51,20 @@ function renderAttentionBlock(attention, body) {
         '</square-activity>',
     ].join('\n');
 }
+function renderDirectBlock(attention) {
+    return escapeSquareTags(previewAttentionBody(attention.body, attention.delivery));
+}
 /** Shared model-facing envelope; transport correlation and human cards stay outside it. */
-export function renderSquareReminder(previews) {
+export function renderSquareReminder(previews, deliveries = []) {
     if (previews.length === 0)
         return '';
+    const header = deliveries.some(item => item?.mode === 'direct')
+        ? 'This is an external notification, not a direct message from the user.'
+        : 'This is an external reminder from Square, not a direct message from the user.';
     return [
         '',
         '<system-reminder>',
-        'This is an external reminder from Square, not a direct message from the user.',
+        header,
         '',
         previews.join('\n\n'),
         '</system-reminder>',
@@ -64,6 +72,8 @@ export function renderSquareReminder(previews) {
     ].join('\n');
 }
 export function renderAttentionPreview(attention) {
+    if (attention.delivery?.mode === 'direct')
+        return renderDirectBlock(attention);
     const remaining = attention.body.replace(/\r\n/g, '\n').length - ATTENTION_BODY_MAX;
     const attributes = [
         `square="${escapeAttribute(displayAttentionPath(attention.squarePath))}"`,

package/dist/boundary-presentation.js

@@ -14,36 +14,43 @@ export function renderPendingAtBoundary(inbox) {
 function renderBoundary(inbox) {
     const queued = inbox.flatMap((membership) => membership.notifications.map((notification) => ({ membership, notification })));
     const blocks = [];
+    const agoraBlocks = [];
+    const deliveries = [];
+    let remainingAgora = queued.filter(({ notification }) => notification.delivery?.mode !== 'direct').length;
     const complete = [];
     let omitted = 0;
     const omission = (count) => `${count} more ${count === 1 ? 'activity' : 'activities'} not shown.`;
-    for (const [index, entry] of queued.entries()) {
+    for (const entry of queued) {
         const { membership, notification } = entry;
-        const block = [
-            renderAttentionPreview({
-                squarePath: membership.location,
-                actIndex: notification.actIndex,
-                recipient: membership.seat.participant,
-                actor: notification.actor,
-                route: notification.route,
-                body: notification.body,
-            }),
-        ].join('\n');
-        const omittedAfter = omitted + queued.length - index - 1;
-        const prospective = renderSquareReminder([...blocks, block, ...(omittedAfter > 0 ? [omission(omittedAfter)] : [])]);
-        if (prospective.length > CONTEXT_MAX) {
-            omitted += 1;
-            continue;
+        const block = renderAttentionPreview({
+            squarePath: membership.location,
+            actIndex: notification.actIndex,
+            recipient: membership.seat.participant,
+            actor: notification.actor,
+            route: notification.route,
+            body: notification.body,
+            delivery: notification.delivery,
+        });
+        if (notification.delivery?.mode !== 'direct') {
+            remainingAgora -= 1;
+            const omittedAfter = omitted + remainingAgora;
+            const prospective = renderSquareReminder([...agoraBlocks, block, ...(omittedAfter > 0 ? [omission(omittedAfter)] : [])]);
+            if (prospective.length > CONTEXT_MAX) {
+                omitted += 1;
+                continue;
+            }
+            agoraBlocks.push(block);
         }
         blocks.push(block);
+        deliveries.push(notification.delivery);
         complete.push({
             membership,
-            actIndexes: [notification.actIndex],
-            markSeen: !attentionBodyIsClipped(notification.body),
+            actIndex: notification.actIndex,
+            markSeen: !attentionBodyIsClipped(notification.body, notification.delivery),
         });
     }
     return {
-        context: renderSquareReminder([...blocks, ...(omitted > 0 ? [omission(omitted)] : [])]),
+        context: renderSquareReminder([...blocks, ...(omitted > 0 ? [omission(omitted)] : [])], deliveries),
         complete,
     };
 }
@@ -67,12 +74,10 @@ async function presentPendingAtBoundaryUnlocked(identity, present, lookup = sess
                     artifact = createArtifactPort(location);
                     artifacts.set(location, artifact);
                 }
-                for (const index of entry.actIndexes) {
-                    const claim = await preparePendingPresentation({ artifact, location, participant: seat.participant,
-                        activity: index, seat, markSeen: entry.markSeen, signal });
-                    if (claim !== undefined)
-                        claims.push({ key: pendingKey(entry.membership, index), claim });
-                }
+                const claim = await preparePendingPresentation({ artifact, location, participant: seat.participant,
+                    activity: entry.actIndex, seat, markSeen: entry.markSeen, signal });
+                if (claim !== undefined)
+                    claims.push({ key: pendingKey(entry.membership, entry.actIndex), claim });
             }
         }
         catch (error) {
@@ -85,7 +90,7 @@ async function presentPendingAtBoundaryUnlocked(identity, present, lookup = sess
             const fresh = renderBoundary(pending.map(membership => ({ ...membership,
                 notifications: membership.notifications.filter(note => eligible.has(pendingKey(membership, note.actIndex))),
             })));
-            const included = new Set(fresh.complete.flatMap(entry => entry.actIndexes.map(index => pendingKey(entry.membership, index))));
+            const included = new Set(fresh.complete.map(entry => pendingKey(entry.membership, entry.actIndex)));
             return { payload: fresh.context, included: claims.filter(({ key }) => included.has(key)).map(({ claim }) => claim) };
         }, present, { signal, classifyError: () => 'failed' });
         if (report.observation.kind === 'threw')

package/dist/channel.d.ts

@@ -0,0 +1,74 @@
+import { type HarnessSessionChannel } from './participant-identity.js';
+import type { SquareResourceOwner, WakeTransportPort } from './ports.js';
+import type { ActivityId, ChannelSendInput, ChannelSendResult, DeliveryDeferral, HeldSeat, MetadataMatch, OperationControl, Owner, Participant, WakeAddress, PendingOptions, PendingResult, AckResult } from './square-facade.js';
+export { harnessOwner, decodeHarnessOwner, localUserOwner } from './owner.js';
+export type { ActivityDelivery, ActivityMetadata, ChannelTruncate, PerceivedActivity, PendingOptions, PendingResult, AckResult } from './square-facade.js';
+export type { ActivityId, ChannelSendInput, ChannelSendResult, DeliveryDeferral, HeldSeat, MetadataMatch, OperationControl, Owner, WakeAddress, SquareResourceOwner, WakeTransportPort, HarnessSessionChannel };
+export interface ResolvedHarnessSession {
+    readonly channel: HarnessSessionChannel;
+    readonly sessionId: string;
+    readonly agentId?: string;
+    readonly owner: Owner;
+    readonly wakeAddress?: WakeAddress;
+}
+export declare function resolveHarnessSession(env?: NodeJS.ProcessEnv): ResolvedHarnessSession | undefined;
+export interface ChannelOpenInput {
+    readonly path: string;
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly clock?: () => number;
+    readonly wakeTransport?: WakeTransportPort | false;
+    readonly resources?: SquareResourceOwner;
+}
+export interface ChannelCreateInput extends ChannelOpenInput {
+    readonly force?: boolean;
+    readonly description?: string;
+}
+type EndpointOptions = {
+    readonly owner: Owner;
+    readonly wakeAddress?: WakeAddress;
+};
+type EndpointIdentity = {
+    readonly owner: Owner;
+    readonly generation: ActivityId;
+};
+/** A scoped direct-messaging vocabulary over the shared Square resource. */
+export declare class Channel {
+    private readonly square;
+    private constructor();
+    get location(): string;
+    static open(input: ChannelOpenInput, control?: OperationControl): Promise<Channel>;
+    static create(input: ChannelCreateInput, control?: OperationControl): Promise<Channel>;
+    static inMemory(input?: Omit<ChannelCreateInput, 'path' | 'resources' | 'force'>): Channel;
+    attach(name: string, options: EndpointOptions & {
+        readonly takeover?: boolean;
+    }, control?: OperationControl): Promise<ChannelEndpoint>;
+    reattach(name: string, options: EndpointOptions, control?: OperationControl): Promise<ChannelEndpoint | null>;
+    endpoint(name: string, options: {
+        readonly owner: Owner;
+    }): Promise<ChannelEndpoint>;
+    endpointsOf(owner: Owner): Promise<readonly HeldSeat[]>;
+    detach(name: string, identity: EndpointIdentity): Promise<true | null>;
+    remove(name: string, identity: EndpointIdentity): Promise<boolean>;
+    cancelDeliveries(name: string, identity: EndpointIdentity): Promise<boolean>;
+    send(input: ChannelSendInput, control?: OperationControl): Promise<ChannelSendResult>;
+    close(): Promise<void>;
+}
+/** Captures one recipient generation through its existing Participant handle. */
+export declare class ChannelEndpoint {
+    private readonly channel;
+    private readonly participant;
+    constructor(channel: Channel, participant: Participant);
+    get name(): string;
+    get generation(): ActivityId;
+    pending(options?: PendingOptions, control?: OperationControl): Promise<PendingResult>;
+    ack(ids: readonly ActivityId[], control?: OperationControl): Promise<AckResult>;
+    leave(control?: OperationControl): Promise<void>;
+    deferDelivery(input: Readonly<{
+        match: MetadataMatch;
+        durationMs: number;
+    }>, control?: OperationControl): Promise<DeliveryDeferral>;
+    renewDeliveryDeferral(id: string, durationMs: number, control?: OperationControl): Promise<DeliveryDeferral | null>;
+    releaseDeliveryDeferral(id: string, control?: OperationControl): Promise<boolean>;
+    send(input: Omit<ChannelSendInput, 'from'>, control?: OperationControl): Promise<ChannelSendResult>;
+}

package/dist/channel.js

@@ -0,0 +1,92 @@
+import { codexWakeAddress } from './codex-address.js';
+import { SquareError } from './model.js';
+import { harnessOwner } from './owner.js';
+import { harnessSessionSources } from './participant-identity.js';
+import { Square } from './square-api.js';
+import { squareLocation } from './square-location.js';
+export { harnessOwner, decodeHarnessOwner, localUserOwner } from './owner.js';
+export function resolveHarnessSession(env = process.env) {
+    for (const { variable, channel } of harnessSessionSources) {
+        const sessionId = env[variable]?.trim();
+        if (!sessionId)
+            continue;
+        const agentId = channel === 'claude-code' && env.CLAUDE_CODE_CHILD_SESSION?.trim() === '1'
+            ? env.CLAUDE_CODE_AGENT_ID?.trim() || undefined : undefined;
+        const wakeAddress = channel === 'codex' ? codexWakeAddress(sessionId, env)
+            : channel === 'paseo' ? { kind: 'paseo', address: { agentId: sessionId } } : undefined;
+        return { channel, sessionId, ...(agentId === undefined ? {} : { agentId }),
+            owner: harnessOwner({ channel, session: sessionId, ...(agentId === undefined ? {} : { agent: agentId }) }),
+            ...(wakeAddress === undefined ? {} : { wakeAddress }) };
+    }
+    return undefined;
+}
+function explicitLocation(input) {
+    if (typeof input?.path !== 'string' || input.path.trim() === '')
+        throw new SquareError('invalid_args', 'Channel path is required.');
+    return squareLocation(input);
+}
+/** A scoped direct-messaging vocabulary over the shared Square resource. */
+export class Channel {
+    square;
+    constructor(square) {
+        this.square = square;
+    }
+    get location() { return this.square.location; }
+    static async open(input, control) {
+        const path = explicitLocation(input);
+        return new Channel(await Square.at({ ...input, path }, control));
+    }
+    static async create(input, control) {
+        const path = explicitLocation(input);
+        return new Channel(await Square.build({ ...input, path, hardCap: null, markdown: input.description ?? '# Channel\n' }, control));
+    }
+    static inMemory(input = {}) {
+        return new Channel(Square.inMemory({ ...input, hardCap: null, markdown: input.description ?? '# Channel\n' }));
+    }
+    async attach(name, options, control) {
+        return new ChannelEndpoint(this, (await this.square.join(name, options, control)).participant);
+    }
+    async reattach(name, options, control) {
+        const participant = await this.square.reattach(name, options, control);
+        return participant === null ? null : new ChannelEndpoint(this, participant);
+    }
+    async endpoint(name, options) {
+        return new ChannelEndpoint(this, await this.square.participant(name, options));
+    }
+    endpointsOf(owner) { return this.square.seatsOf(owner); }
+    detach(name, identity) { return this.square.detach(name, identity); }
+    async remove(name, identity) { return await this.square.endHeld(name, identity) !== null; }
+    cancelDeliveries(name, identity) { return this.square.cancelDeliveries(name, identity); }
+    send(input, control) { return this.square.send(input, control); }
+    close() { return this.square.close(); }
+}
+/** Captures one recipient generation through its existing Participant handle. */
+export class ChannelEndpoint {
+    channel;
+    participant;
+    constructor(channel, participant) {
+        this.channel = channel;
+        this.participant = participant;
+    }
+    get name() { return this.participant.name; }
+    get generation() { return this.participant.generation; }
+    pending(options, control) {
+        return this.participant.pending(options, control);
+    }
+    ack(ids, control) {
+        return this.participant.ack(ids, control);
+    }
+    async leave(control) { await this.participant.done(undefined, {}, control); }
+    deferDelivery(input, control) {
+        return this.participant.deferDelivery(input, control);
+    }
+    renewDeliveryDeferral(id, durationMs, control) {
+        return this.participant.renewDeliveryDeferral(id, durationMs, control);
+    }
+    releaseDeliveryDeferral(id, control) {
+        return this.participant.releaseDeliveryDeferral(id, control);
+    }
+    send(input, control) {
+        return this.channel.send({ ...input, from: this.name }, control);
+    }
+}

package/dist/claude-delivery.js

@@ -12,12 +12,6 @@ const marker = /(?:^|\n)\[square-inbox:([a-zA-Z0-9-]+)\](?:\n|$)/g;
 export function nativeTokens(text) { return [...text.matchAll(marker)].map((match) => match[1]); }
 export function nativePayload(token, preview) { return `[square-inbox:${token}]\n${preview}\n[/square-inbox:${token}]`; }
 function nativeSupported(route) { return route.address.loaded === 'true' && !!route.address.endpoint; }
-function sameAddress(left, right) {
-    if (left === undefined)
-        return false;
-    const keys = Object.keys(left);
-    return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
-}
 function hashPayload(payload) { return createHash('sha256').update(payload).digest('hex'); }
 function previewFacts(facts, request) {
     const index = parseActivityId(request.activity);
@@ -80,8 +74,7 @@ function currentPayload(facts, request) {
     const seat = facts.seat(request.participant), evidence = facts.deliveryByToken(request.claimToken);
     if (seat === undefined || seat.attachment !== 'attached' || evidence === undefined || seat.generation !== evidence.generation
         || seat.generation !== request.seat.generation || seat.owner !== request.seat.owner
-        || evidence.activity !== request.activity || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome)
-        || seat.wakeAddress?.kind !== 'claude-native' || !sameAddress(seat.wakeAddress.address, request.route.address))
+        || evidence.activity !== request.activity || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome))
         return undefined;
     const native = previewFacts(facts, request);
     if (native === undefined)
@@ -150,7 +143,8 @@ export async function observeClaudeDelivery(sessionId, text, operation, env = pr
                 return { recognized, current: false };
             if (operation === 'stored')
                 await presentPending({ artifact: row.artifact, location: request.location,
-                    participant: request.participant, activity: request.activity, seat: request.seat, sink: { present() { } },
+                    // Claude's stored event consumes even Agora previews; retain that contract for both modes.
+                    participant: request.participant, activity: request.activity, seat: request.seat, markSeen: true, sink: { present() { } },
                     current: facts => currentPayload(facts, request) === payload });
         }
         return { recognized, current: true };

package/dist/cli/observation-commands.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { once } from 'node:events';
 import { runClaudeMod } from '../claude-mod.js';
-import { runCodexHookAsync } from '../codex-hook.js';
+import { runCodexHook } from '../codex-hook.js';
 import { isSquareError } from '../model.js';
 import { commandPrefix, participantIdentity, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
 import { PARTICIPANTS_DEFAULT_LIMIT, PARTICIPANTS_MAX_LIMIT, renderHistoryResult, renderParticipantsResult, renderStatusResult, } from '../operation-presentation.js';
@@ -523,4 +523,4 @@ function hookCommand(runHook) {
     };
 }
 export const claudeModCommand = hookCommand(runClaudeMod);
-export const codexHookCommand = hookCommand(runCodexHookAsync);
+export const codexHookCommand = hookCommand(runCodexHook);

package/dist/codex-hook.d.ts

@@ -5,10 +5,8 @@ export interface CodexHookInput {
     session_id?: unknown;
     hook_event_name?: unknown;
     cwd?: unknown;
-    source?: unknown;
 }
 export type HookTrace = (line: string) => void;
 export declare const CODEX_HOOK_BUDGET_MS = 4500;
 export declare function codexHookResponse(input: CodexHookInput, lookup?: (identity: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, deliveryTransports?: WakeTransports, trace?: HookTrace): Promise<object | undefined>;
 export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
-export declare const runCodexHookAsync: typeof runCodexHook;

package/dist/codex-hook.js

@@ -47,4 +47,3 @@ export async function runCodexHook(inputText, env = process.env) {
     const result = await codexHookResponse(input, sessionInbox, env);
     return result === undefined ? '' : `${JSON.stringify(result)}\n`;
 }
-export const runCodexHookAsync = runCodexHook;

package/dist/decisions.d.ts

@@ -7,12 +7,7 @@ type TimedAct<K extends Act['kind'] = Act['kind']> = Extract<Act, {
 };
 import type { ExpressResult, ParticipantSummary, UnreadActivitySummary } from './square-facade.js';
 export declare function resolveKnownName(facts: SquareRead, name: string): string;
-export interface DecideJoinResult {
-    joinedName: string;
-    addParticipant: boolean;
-    joinAct?: TimedAct<'join'>;
-}
-export declare function decideJoin(facts: SquareRead, name: string, now: number): DecideJoinResult;
+export declare function decideJoin(facts: SquareRead, name: string, now: number): TimedAct<'join'> | undefined;
 export type ActDecision = ({
     type: 'sent';
     act: TimedAct;
@@ -21,8 +16,6 @@ export type ActDecision = ({
     activitySummaries: UnreadActivitySummary[];
 } | {
     type: 'capped';
-    count: number;
-    hardCap: number;
 } | {
     type: 'throttled';
     delayMs: number;
@@ -45,9 +38,7 @@ export declare function decideAct(facts: SquareRead, input: {
 }): ActDecision;
 export declare function validateDoneBody(body: unknown): void;
 export declare function coreDone(facts: SquareRead, name: string, body: string, now: number): TimedAct<'done'>;
-export declare function coreListen(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
-export declare function coreIgnore(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
-export declare function coreUnlisten(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
+export declare function attentionChange(facts: SquareRead, kind: 'listen' | 'ignore' | 'unlisten', actor: string, target: string, now: number): TimedAct<'listen' | 'ignore' | 'unlisten'> | undefined;
 export declare function coreListening(facts: SquareRead, actor: string): readonly string[];
 export declare function compareParticipantActivity(a: Pick<ParticipantSummary, 'name' | 'lastActiveAt'>, b: Pick<ParticipantSummary, 'name' | 'lastActiveAt'>): number;
 export declare function coreParticipants(facts: SquareRead, now: number): ParticipantSummary[];

package/dist/decisions.js

@@ -13,9 +13,7 @@ export function resolveKnownName(facts, name) {
 export function decideJoin(facts, name, now) {
     validateName(name);
     const current = facts.participant(name);
-    const joinedName = current?.name ?? name;
-    return current?.joined ? { joinedName, addParticipant: false }
-        : { joinedName, addParticipant: current === undefined, joinAct: { kind: 'join', actor: joinedName, at: now } };
+    return current?.joined ? undefined : { kind: 'join', actor: current?.name ?? name, at: now };
 }
 function validateActivityName(name) {
     try {
@@ -131,7 +129,7 @@ export function decideAct(facts, input) {
     if (!current.joined)
         throw activityRefusal('not_joined', `${name} has not joined this square`);
     if (header.hardCap !== null && current.sayCount >= header.hardCap)
-        return { type: 'capped', count: current.sayCount, hardCap: header.hardCap };
+        return { type: 'capped' };
     if (reach === 'bell') {
         const recent = facts.recentSayTimes(now - 3600000, 1, name, true);
         if (recent.length > 0)
@@ -162,7 +160,7 @@ export function coreDone(facts, name, body, now) {
     requireStanding(current);
     return { kind: 'done', actor: current.name, at: now };
 }
-function attentionChange(facts, kind, actor, target, now) {
+export function attentionChange(facts, kind, actor, target, now) {
     const current = resolveStanding(facts, actor);
     validateName(target);
     requireStanding(current);
@@ -175,9 +173,6 @@ function attentionChange(facts, kind, actor, target, now) {
     }
     return existing?.kind === kind ? undefined : { kind, actor: current.name, target, at: now };
 }
-export function coreListen(facts, actor, target, now) { return attentionChange(facts, 'listen', actor, target, now); }
-export function coreIgnore(facts, actor, target, now) { return attentionChange(facts, 'ignore', actor, target, now); }
-export function coreUnlisten(facts, actor, target, now) { return attentionChange(facts, 'unlisten', actor, target, now); }
 export function coreListening(facts, actor) {
     const current = resolveStanding(facts, actor);
     return facts.attention(current.name).filter((item) => item.kind === 'listen').map((item) => item.target);

package/dist/delivery-health.js

@@ -32,17 +32,7 @@ export async function classifyDeliveryHealth(squarePath, opts) {
                 || row.outcome === 'dispatching' && (row.expiresAt === undefined || row.expiresAt > now)));
             const terminal = evidence.findLast((row) => row.kind === 'wake' && (row.outcome === 'accepted' || row.outcome === 'unknown'));
             const attemptRow = evidence.findLast((row) => row.kind === 'wake' && (row.outcome === 'accepted' || row.outcome === 'unknown' || row.outcome === 'failed'));
-            const attempt = attemptRow === undefined || seat === undefined || attemptRow.route?.kind === undefined ? undefined : {
-                at: attemptRow.at,
-                attention: { squarePath, recipient: seat.participant, actIndex: note.index },
-                routeKind: attemptRow.route.kind,
-                outcome: attemptRow.outcome,
-                attemptN: attemptRow.attemptN,
-                ...(attemptRow.signature === undefined ? {} : { signature: attemptRow.signature }),
-                ...(attemptRow.message === undefined ? {} : { message: attemptRow.message }),
-                ...(attemptRow.diagnostic === undefined ? {} : { diagnostic: attemptRow.diagnostic }),
-                ...(attemptRow.nativeObservations === undefined ? {} : { nativeObservations: attemptRow.nativeObservations }),
-            };
+            const attempt = attemptRow === undefined || seat === undefined ? undefined : deliveryAttempt(squarePath, attemptRow, { squarePath, recipient: seat.participant, actIndex: note.index });
             const kind = presentation
                 ? 'presented-not-delivered'
                 : terminal?.outcome === 'accepted'
@@ -127,12 +117,12 @@ function formatRelease(release, now) {
     const diagnostic = release.diagnostic === undefined ? '' : ` · ${displayField(JSON.stringify(release.diagnostic))}`;
     return `  · ${formatActivityId(release.attention.actIndex)} → ${displayField(participantIdentity(release.attention.recipient))} · ${route} · ${reason} · ${age}${message}${diagnostic}`;
 }
-function deliveryAttempt(squarePath, row) {
+function deliveryAttempt(squarePath, row, attention = { squarePath, recipient: row.participant, actIndex: Number(row.activity.slice(4)) }) {
     if (row.route?.kind === undefined || row.outcome === 'released' || row.outcome === 'dispatching')
         return undefined;
     return {
         at: row.at,
-        attention: { squarePath, recipient: row.participant, actIndex: Number(row.activity.slice(4)) },
+        attention,
         routeKind: row.route.kind,
         outcome: row.outcome,
         attemptN: row.attemptN,

package/dist/delivery.d.ts

@@ -1,14 +1,6 @@
-import type { DirectedNotificationRoute, StoredAct, WatchLease } from './model.js';
+import type { DirectedNotificationRoute, WatchLease } from './model.js';
 import type { DeliveryEvidence, DirectedHead, ParticipantFact, SquareArtifactPort, SquareRead, WakeRequest } from './ports.js';
 export type { DirectedNotificationRoute } from './model.js';
-export type SayItem = StoredAct & {
-    kind: 'say';
-};
-export interface PlannedNotification {
-    item: SayItem;
-    recipient: string;
-    route: DirectedNotificationRoute;
-}
 /** Exact stored activity projection for transports that send an awareness reminder. */
 export declare function wakePreview(facts: SquareRead, request: WakeRequest): string | undefined;
 export interface RoutedNotification {
@@ -26,8 +18,6 @@ export declare function pendingHead(facts: SquareRead, name: string, index: numb
 export declare function pendingRecipients(facts: SquareRead, index: number): DirectedHead[];
 /** Still-pending directed heads for one recipient, oldest first. Bodies belong to presentation. */
 export declare function pendingHeads(facts: SquareRead, name: string): DirectedHead[];
-/** Complete recipient projection, assembled inside its one transaction. */
-export declare function pendingNotifications(facts: SquareRead, name: string): PlannedNotification[];
 export interface PendingScan {
     readonly roster: readonly ParticipantFact[];
     readonly throughIndex: number;

package/dist/delivery.js

@@ -14,8 +14,8 @@ export function wakePreview(facts, request) {
         return undefined;
     return renderSquareReminder([renderAttentionPreview({
             squarePath: request.location, recipient: request.participant, actIndex: item.index,
-            actor: item.actor, route: head.route, body: item.body ?? '(structured activity)',
-        })]);
+            actor: item.actor, route: head.route, body: item.body ?? '(structured activity)', delivery: item.delivery,
+        })], [item.delivery]);
 }
 function custody(evidence) {
     return evidence.map(row => ({ purpose: row.kind === 'wake' ? 'dispatch' : 'presentation', outcome: row.outcome, expiresAt: row.expiresAt }));
@@ -58,13 +58,6 @@ export function pendingHeads(facts, name) {
     }
     return heads;
 }
-/** Complete recipient projection, assembled inside its one transaction. */
-export function pendingNotifications(facts, name) {
-    const heads = pendingHeads(facts, name), recipient = heads[0]?.recipient ?? name;
-    const routes = new Map(heads.map((head) => [head.index, head.route]));
-    return facts.activities(heads.map((head) => head.index)).flatMap((item) => item.kind === 'say'
-        ? [{ item, recipient, route: routes.get(item.index) }] : []);
-}
 export function capturePendingScan(facts) {
     return { roster: facts.roster().filter((participant) => participant.joined), throughIndex: facts.header().lastActIndex };
 }