@astrosheep/square 0.3.96 → 0.3.98

package/dist/activity-query.d.ts

@@ -0,0 +1,4 @@
+import type { ActivityFilter } from './ports.js';
+import type { ActivityQuery } from './square-facade.js';
+/** Both public read paths compile the same filters; neither resolves senders through membership. */
+export declare function activityQueryFilter(query: ActivityQuery, extraFields?: readonly string[]): ActivityFilter;

package/dist/activity-query.js

@@ -0,0 +1,51 @@
+import { SquareError, validateName } from './model.js';
+import { parseActivityId } from './square-core.js';
+import { validateMetadataMatch } from './delivery-deferral.js';
+import { compileSearchPattern } from './search.js';
+/** Both public read paths compile the same filters; neither resolves senders through membership. */
+export function activityQueryFilter(query, extraFields = []) {
+    const fail = (message) => { throw new SquareError('invalid_args', message); };
+    const fields = ['at', 'from', 'match', 'search', 'cursor', 'limit', ...extraFields];
+    if (typeof query !== 'object' || query === null || Array.isArray(query))
+        fail('Activity query must be an object.');
+    for (const field of Object.keys(query))
+        if (!fields.includes(field))
+            fail(`Unknown activity query field: ${field}`);
+    const indexes = query.at === undefined ? undefined : !Array.isArray(query.at) ? fail('Query at must be an array of activity IDs.')
+        : Array.from(query.at, id => {
+            const index = parseActivityId(id);
+            return index === undefined ? fail(`Invalid activity id: ${id}`) : index;
+        });
+    const actors = query.from === undefined ? undefined : !Array.isArray(query.from) ? fail('Query from must be an array of sender names.')
+        : Array.from(query.from, name => {
+            if (typeof name !== 'string')
+                fail('Query from must contain sender names.');
+            validateName(name);
+            return name;
+        });
+    const metadataMatch = query.match === undefined ? undefined : validateMetadataMatch(query.match);
+    let afterIndex, beforeIndex;
+    if (query.cursor !== undefined) {
+        const cursor = query.cursor;
+        if (typeof cursor !== 'object' || cursor === null || Array.isArray(cursor)
+            || !['before', 'after'].includes(cursor.direction) || Object.keys(cursor).some(key => !['id', 'direction'].includes(key)))
+            fail('Query cursor requires an activity ID and before/after direction.');
+        const index = parseActivityId(cursor.id);
+        if (index === undefined)
+            fail(`Invalid activity id: ${cursor.id}`);
+        if (cursor.direction === 'after')
+            afterIndex = index;
+        else
+            beforeIndex = index;
+    }
+    let search = query.search;
+    if (search !== undefined) {
+        if (typeof search !== 'object' || search === null || Array.isArray(search)
+            || typeof search.text !== 'string' || search.text === '' || !['literal', 'regex'].includes(search.mode)
+            || Object.keys(search).some(key => !['text', 'mode'].includes(key)))
+            fail('Query search requires non-empty text and literal/regex mode.');
+        compileSearchPattern(search.text, search.mode === 'literal');
+        search = { text: search.text, mode: search.mode };
+    }
+    return { indexes, actors, metadataMatch, search, afterIndex, beforeIndex };
+}

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/boundary-presentation.js

@@ -22,17 +22,15 @@ function renderBoundary(inbox) {
     const omission = (count) => `${count} more ${count === 1 ? 'activity' : 'activities'} not shown.`;
     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,
-                delivery: notification.delivery,
-            }),
-        ].join('\n');
+        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;
@@ -47,7 +45,7 @@ function renderBoundary(inbox) {
         deliveries.push(notification.delivery);
         complete.push({
             membership,
-            actIndexes: [notification.actIndex],
+            actIndex: notification.actIndex,
             markSeen: !attentionBodyIsClipped(notification.body, notification.delivery),
         });
     }
@@ -76,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) {
@@ -94,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

@@ -1,8 +1,8 @@
 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 } from './square-facade.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 } from './square-facade.js';
+export type { ActivityDelivery, ActivityMetadata, ActivityQuery, ActivitySearch, ActivityCursor, 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;
@@ -61,6 +61,8 @@ export declare class ChannelEndpoint {
     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;

package/dist/channel.js

@@ -70,6 +70,12 @@ export class ChannelEndpoint {
     }
     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);

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)

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';
@@ -375,8 +375,11 @@ function parseHistory(argv, context) {
     if (before !== undefined && after !== undefined)
         fail('--before and --after cannot be combined.');
     return {
-        query: { limit, from: participants, since, after, before, at: at.length === 0 ? undefined : at,
-            contextBefore: beforeContext, contextAfter: afterContext, mention, grep, fixed, order },
+        query: { limit, from: participants.length === 0 ? undefined : participants, since,
+            cursor: after !== undefined ? { id: after, direction: 'after' } : before === undefined ? undefined : { id: before, direction: 'before' },
+            at: at.length === 0 ? undefined : at,
+            contextBefore: beforeContext, contextAfter: afterContext, mention, order,
+            search: grep !== undefined ? { text: grep, mode: 'regex' } : fixed === undefined ? undefined : { text: fixed, mode: 'literal' } },
         noTruncate, format,
         continuationArgs: historyContinuationArgs(argv),
     };
@@ -523,4 +526,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

@@ -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 };
 }

package/dist/identity.d.ts

@@ -8,6 +8,5 @@ export declare const SQUARE_IDENTITY: Readonly<{
     cliName: "square";
     pluginId: "square@astrosheep";
     hookCommand: "square codex-hook";
-    hookMarker: "square-codex-hook";
     clientName: "astrosheep_square";
 }>;

package/dist/identity.js

@@ -22,6 +22,5 @@ export const SQUARE_IDENTITY = Object.freeze({
     cliName: 'square',
     pluginId: 'square@astrosheep',
     hookCommand: 'square codex-hook',
-    hookMarker: 'square-codex-hook',
     clientName: 'astrosheep_square',
 });

package/dist/inbox.js

@@ -3,7 +3,7 @@ import { indexedSquareEntries, observeSquareIndex } from './square-index.js';
 import { canonicalPath } from './canonical-path.js';
 import { formatActivityId, parseActivityId } from './square-core.js';
 import { freshWatchLease, WATCH_STALE_MS } from './runtime.js';
-import { pendingHead, pendingNotifications, leaseOwnsNotification } from './delivery.js';
+import { pendingHead, pendingHeads, leaseOwnsNotification } from './delivery.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { attentionBodyIsClipped, renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
 export function pendingKey(membership, actIndex) {
@@ -146,12 +146,14 @@ async function projectPending(candidates, cache, signal) {
                 const header = facts.header();
                 let cached = cache?.get(location);
                 if (cached?.coordinate !== coordinate || cached.version !== header.revision) {
-                    cached = { coordinate, version: header.revision, value: locatedSeats(facts, location, seats).map(membership => ({
-                            ...membership, notifications: pendingNotifications(facts, membership.seat.participant).map(({ item, route }) => ({
-                                actIndex: item.index, actor: item.actor, at: item.at, body: item.body ?? '(structured activity)', route,
-                                ...(item.delivery === undefined ? {} : { delivery: item.delivery }),
-                            })),
-                        })) };
+                    cached = { coordinate, version: header.revision, value: locatedSeats(facts, location, seats).map(membership => {
+                            const heads = pendingHeads(facts, membership.seat.participant);
+                            const routes = new Map(heads.map(head => [head.index, head.route]));
+                            return { ...membership, notifications: facts.activities(heads.map(head => head.index)).flatMap(item => item.kind === 'say'
+                                    ? [{ actIndex: item.index, actor: item.actor, at: item.at, body: item.body ?? '(structured activity)',
+                                            route: routes.get(item.index), ...(item.delivery === undefined ? {} : { delivery: item.delivery }) }]
+                                    : []) };
+                        }) };
                 }
                 // Cache conversation content, never leases or delivery eligibility: evidence can change
                 // without a conversation revision and must not force body hydration or self-wake retries.

package/dist/notifications.d.ts

@@ -1,6 +1,5 @@
 import { type WakeRouteKind } from './model.js';
 import type { WakeTransportPort } from './ports.js';
-export type { PlannedNotification } from './delivery.js';
 export declare const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export declare function wakeGraceMs(env?: NodeJS.ProcessEnv): number;
 export type WakeTransports = Readonly<Partial<Record<WakeRouteKind, WakeTransportPort>>>;
@@ -24,3 +23,4 @@ export interface SweepPendingNotificationsOptions {
 }
 /** Select old pending attention at a bounded action boundary for an explicit executor. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;
+export {};

package/dist/operation-presentation.js

@@ -155,10 +155,8 @@ function historyQueryArgs(query) {
         args.push('-A', String(query.contextAfter));
     if (query.mention !== undefined)
         args.push('--mention', query.mention);
-    if (query.grep !== undefined)
-        args.push('--grep', query.grep);
-    if (query.fixed !== undefined)
-        args.push('--fixed', query.fixed);
+    if (query.search !== undefined)
+        args.push(query.search.mode === 'regex' ? '--grep' : '--fixed', query.search.text);
     if (query.order !== undefined)
         args.push('--order', query.order);
     return args;
@@ -169,10 +167,10 @@ export function renderHistoryResult(squarePath, data, options = {}) {
         return undefined;
     const query = options.query ?? {};
     const noTruncate = options.noTruncate === true;
-    const pattern = query.grep ?? query.fixed;
-    const output = pattern === undefined || pattern === ''
+    const search = query.search;
+    const output = search === undefined
         ? renderHistoryProjection(projection, projection.visibleActivities, noTruncate, squarePath)
-        : renderGrepActivitiesView(projection.visibleActivities, projection.totalMatches, noTruncate, squarePath, pattern, query.fixed !== undefined, () => 'full');
+        : renderGrepActivitiesView(projection.visibleActivities, projection.totalMatches, noTruncate, squarePath, search.text, search.mode === 'literal', () => 'full');
     const next = projection.continuation;
     const base = options.continuationArgs ?? historyQueryArgs(query);
     const continuation = next === undefined ? '' : `\n\n${historyContinuationCommand(squarePath, [...base, `--${next.direction}`, next.cursor, '--limit', String(next.limit)])}`;

package/dist/ports.d.ts

@@ -1,6 +1,7 @@
 import type { Act, ActivityId, Owner, HardCap, Seat, StoredAct, WakeAddress, WakeRoute, WatchLease } from './model.js';
 import type { AttemptOutcome } from './delivery-attempts.js';
 import type { MetadataMatch, DeliveryDeferralFact } from './delivery-deferral.js';
+import type { ActivitySearch } from './square-facade.js';
 export type ActivityIndex = number;
 export interface SquareHeader {
     readonly revision: number;
@@ -49,6 +50,9 @@ export interface ActivityFilter {
     readonly actors?: readonly string[];
     readonly actorMatch?: 'identity' | 'exact';
     readonly afterAt?: number;
+    /** Shared query predicates, applied before paging or counting. */
+    readonly metadataMatch?: MetadataMatch;
+    readonly search?: ActivitySearch;
 }
 export interface IndexPage {
     readonly edge: 'oldest' | 'newest';
@@ -58,10 +62,7 @@ export interface FactPage<T> {
     readonly items: readonly T[];
     readonly hasMore: boolean;
 }
-export interface DirectedFilter {
-    readonly afterIndex?: number;
-    readonly beforeIndex?: number;
-    readonly throughIndex?: number;
+export interface DirectedFilter extends Omit<ActivityFilter, 'actors' | 'actorMatch'> {
     readonly unseenOnly?: true;
     readonly senders?: readonly string[];
     readonly attentionOnly?: true;
@@ -78,10 +79,6 @@ export interface ReceiptFacts {
     readonly latestAt?: number;
     readonly latestActorActivityIndex?: number;
 }
-export interface ReceiptAssignment {
-    readonly owner: string;
-    readonly index: ActivityIndex;
-}
 export type SeatRef = Pick<Seat, 'participant' | 'owner' | 'generation'>;
 export type ArtifactWriteAuthority = {
     readonly kind: 'send';
@@ -202,7 +199,6 @@ export interface SquareRead {
         readonly at: number;
     } | undefined;
     receiptFacts(requestedName: string, afterIndex: number): ReceiptFacts;
-    receiptAssignments(): readonly ReceiptAssignment[];
     lease(requestedName: string): WatchLease | undefined;
     deliveryDeferrals(participant: string, generation: ActivityId): readonly DeliveryDeferralFact[];
 }

package/dist/search.js

@@ -1,7 +1,6 @@
-// Shared activity-body search semantics for filtering and presentation.
-// Regex mode intentionally uses JavaScript's built-in engine: patterns come from
-// the local CLI user and are not treated as a hostile multi-tenant input. Use
-// --fixed for literal text; do not claim regex mode has ReDoS protection.
+// Shared case-insensitive search semantics for storage filtering and presentation.
+// Regex mode intentionally uses JavaScript's built-in engine, without a ReDoS
+// timeout. Callers should use literal mode for plain text and avoid untrusted regexes.
 import { SquareError } from './model.js';
 export function compileSearchPattern(pattern, fixed) {
     if (fixed)
@@ -11,7 +10,7 @@ export function compileSearchPattern(pattern, fixed) {
     }
     catch (err) {
         const detail = err instanceof Error ? err.message.replace(/^Invalid regular expression:\s*/i, '') : 'invalid expression';
-        throw new SquareError('invalid_args', `Invalid --grep regex: ${detail}`);
+        throw new SquareError('invalid_args', `Invalid search regex: ${detail}`);
     }
 }
 function compactWhitespace(text) {

package/dist/sqlite-square.d.ts

@@ -34,7 +34,6 @@ export declare class SqliteSquare {
     join(requested: string, options: JoinOptions, control?: OperationControl): Promise<JoinResult>;
     /** Restore only a standing seat; a concurrent departure or takeover cannot be revived. */
     reattach(name: string, { owner, wakeAddress }: Pick<JoinOptions, 'owner' | 'wakeAddress'>, control?: OperationControl): Promise<Participant | null>;
-    snapshot(control?: OperationControl): Promise<import("./square-facade.js").SquareSnapshot>;
     history(query?: HistoryQuery, control?: OperationControl): Promise<HistoryResult>;
     status(options?: StatusOptions, control?: OperationControl): Promise<StatusResult>;
     participants(options?: ObservationOptions, control?: OperationControl): Promise<ParticipantsResult>;