@astrosheep/square 0.3.22 → 0.3.24

package/claude-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/automatic-session.js

@@ -5,7 +5,6 @@ import { closeOpenSquare } from './open-square.js';
 import { Square } from './square-wiring.js';
 import { entryPresentation } from './views.js';
 import { canonicalSquarePath, lookupSessionBindings, recordSessionDone, recordSessionJoin } from './registry.js';
-import { participantIdentity, renderAmbientEvent } from './presentation.js';
 import { automaticParticipant } from './participant-identity.js';
 export { automaticParticipant } from './participant-identity.js';
 const providerEnv = {
@@ -39,15 +38,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
             return undefined;
         const channel = provider === 'claude' ? 'claude-code' : provider;
         recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
-        const afterSquare = await openSquare(squarePath);
-        const after = await entryPresentation(afterSquare, name, 10).finally(() => closeOpenSquare(afterSquare));
-        const activity = after.recentActivities.map((event) => renderAmbientEvent(event, name, {
-            now: Date.now(),
-            preview: 200,
-            actNumber: event.kind === 'say' ? after.sayNumbers[event.index] : undefined,
-            squareState: after.state,
-        })).filter(Boolean).join('\n\n');
-        return [`You joined the public square as ${participantIdentity(name)}.`, after.scene, after.context ? `context\n${after.context}` : '', activity ? `recent activity\n${activity}` : ''].filter(Boolean).join('\n\n');
+        return undefined;
     }
     finally {
         await square.close();

package/dist/cli/observation-commands.js

@@ -4,7 +4,7 @@ import { sessionInbox } from '../inbox.js';
 import { sweepPendingNotifications } from '../notifications.js';
 import { cmdListSquares } from '../list.js';
 import { parseActivityId, sameName } from '../model.js';
-import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, renderPresenceAnchor, withPathOutput, } from '../presentation.js';
 import { actId, nowMs } from '../runtime.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
@@ -293,8 +293,9 @@ function renderHistoryProjection(projection, visible, full, squarePath, viewer,
             : renderAmbientEvent(activity, viewer, options);
         if (rendered !== '')
             chunks.push(rendered);
-        for (const name of projection.presenceAnchors[activity.index] ?? [])
-            chunks.push(`→ ${participantIdentity(name)} was here`);
+        const participants = projection.presenceAnchors[activity.index];
+        if (participants !== undefined)
+            chunks.push(renderPresenceAnchor(participants));
     }
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';

package/dist/notifications.js

@@ -14,10 +14,10 @@ import { retireWakeRoute } from './routes.js';
 import { openSquare } from './square-file-adapter.js';
 import { markNotificationNotified } from './square-wiring.js';
 import { closeOpenSquare } from './open-square.js';
-import { entryPresentation, notificationDelivered, notificationForAct, pendingDeliveries, resolveParticipant } from './views.js';
+import { entryPresentation, notificationDelivered, notificationForAct, pendingDeliveriesFromState, resolveParticipant } from './views.js';
 import { claimNotificationLease, releaseNotificationLease, transitionNotificationLease } from './wakes.js';
 import { nextWakeAttemptNumber, recordRecoveredUnknown, recordWakeAttempt, } from './wake-attempts.js';
-import { wakeEvidence, wakeIsEligible } from './wake-evidence.js';
+import { wakeEvidence, wakeEvidenceProjectionFromState, wakeIsEligible } from './wake-evidence.js';
 import { WakePort } from './wake-port.js';
 const NOTIFY_LEASE_MS = 5 * 60 * 1000;
 export { planActNotifications, matchesMentionTarget };
@@ -264,13 +264,21 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
     const now = opts.now ?? Date.now();
     const limit = opts.limit ?? 8;
     const square = await openSquare(squarePath, { clock: () => now });
-    const pending = await pendingDeliveries(square).finally(() => closeOpenSquare(square));
+    let state;
+    try {
+        ({ state } = await entryPresentation(square, ''));
+    }
+    finally {
+        await closeOpenSquare(square);
+    }
+    const pending = pendingDeliveriesFromState(state);
+    const evidence = wakeEvidenceProjectionFromState(squarePath, state, now, env);
     const indexes = new Set();
     for (const delivery of pending) {
         for (const note of delivery.notifications) {
             if (now - note.item.at <= wakeGraceMs(env))
                 continue;
-            if (!wakeIsEligible(await wakeEvidence(squarePath, delivery.recipient, note.item.index, now, env)))
+            if (!wakeIsEligible(evidence.evidence(delivery.recipient, note.item.index)))
                 continue;
             indexes.add(note.item.index);
         }

package/dist/presentation.d.ts

@@ -75,6 +75,7 @@ export declare function renderActivityBlocked(opts: ActivityBlockedOptions): str
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
 export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPublicTail(squareState: SquareState, events: StoredAct[], lastN: number | null | undefined, now?: number, viewer?: string): string;
+export declare function renderPresenceAnchor(names: readonly string[]): string;
 export declare function renderActivitiesView(squareState: SquareState, visible: StoredAct[], lastN: number | null | undefined, full: boolean | undefined, squarePath: string, viewer?: string, mode?: 'ambient' | 'archive'): string;
 export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, full: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean): string;
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;

package/dist/presentation.js

@@ -291,8 +291,9 @@ function lastPresenceAnchor(squareState, name) {
     }
     return -1;
 }
-function renderLastPresenceMarker(name) {
-    return `→ ${participantIdentity(name)} was here`;
+export function renderPresenceAnchor(names) {
+    const participants = names.map((name) => participantIdentity(name)).join(', ');
+    return names.length === 1 ? `→ ${participants} was here` : `→ ${participants} were here`;
 }
 export function renderActivitiesView(squareState, visible, lastN, full, squarePath, viewer = '', mode = 'ambient') {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
@@ -315,9 +316,9 @@ export function renderActivitiesView(squareState, visible, lastN, full, squarePa
             : renderAmbientEvent(act, viewer, { ...opts, squareState });
         if (rendered !== '')
             chunks.push(rendered);
-        for (const participant of markers.get(act.index) ?? []) {
-            chunks.push(renderLastPresenceMarker(participant));
-        }
+        const participants = markers.get(act.index);
+        if (participants !== undefined)
+            chunks.push(renderPresenceAnchor(participants));
     }
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';

package/dist/presented.d.ts

@@ -1,5 +1,13 @@
 import { type InboxMembership } from './model.js';
+export interface PresentedAttention {
+    ownerId: string;
+    squarePath: string;
+    name: string;
+    actIndex: number;
+}
 export declare function presentedPath(env?: NodeJS.ProcessEnv): string;
+/** Read the current presentation facts once for a derived evidence projection. */
+export declare function readPresentedAttentions(env?: NodeJS.ProcessEnv, now?: number): PresentedAttention[];
 export declare function hasPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;
 /** True when any current participant owner has already received this attention. */
 export declare function hasPresentedAttention(squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;

package/dist/presented.js

@@ -48,6 +48,15 @@ function readRows(filePath, now = Date.now()) {
     }
     return rows;
 }
+/** Read the current presentation facts once for a derived evidence projection. */
+export function readPresentedAttentions(env = process.env, now = Date.now()) {
+    return readRows(presentedPath(env), now).map((row) => ({
+        ownerId: row.owner_id,
+        squarePath: canonicalSquarePath(row.square_path),
+        name: row.name,
+        actIndex: row.act_index,
+    }));
+}
 function writeRows(filePath, rows) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;

package/dist/registry.d.ts

@@ -28,6 +28,7 @@ export declare function registryPath(): string;
 export declare function canonicalSquarePath(squarePath: string): string;
 export declare function recordJoin(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): void;
 export declare function recordDone(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): void;
+export declare function readActiveBindings(now?: number): RegistryBinding[];
 export declare function lookupSessionBindings(sessionId: string, now?: number): RegistryBinding[];
 export declare function lookupSession(sessionId: string, now?: number): Array<{
     name: string;

package/dist/registry.js

@@ -205,7 +205,7 @@ export function recordJoin(sessionId, name, squarePath, options = {}) {
 export function recordDone(sessionId, name, squarePath, options = {}) {
     writeLifecycle('done', sessionId, name, squarePath, options);
 }
-function readActiveBindings(now = Date.now()) {
+export function readActiveBindings(now = Date.now()) {
     try {
         return foldRegistry(fs.readFileSync(registryPath(), 'utf8'), now);
     }

package/dist/square-storage.js

@@ -116,25 +116,36 @@ export function createFileCell(squarePath) {
     let closed = false;
     let version = 0;
     let fingerprint = fileFingerprint(squarePath);
+    let cached;
     function observe() {
         const next = fileFingerprint(squarePath);
-        if (next === fingerprint)
-            return;
-        fingerprint = next;
-        version += 1;
+        if (next !== fingerprint) {
+            fingerprint = next;
+            cached = undefined;
+            version += 1;
+        }
+        return fingerprint;
+    }
+    function currentState() {
+        const observed = observe();
+        if (cached?.fingerprint === observed)
+            return cloneState(cached.state);
+        const decoded = readSquareFile(squarePath);
+        cached = { fingerprint: observed, state: cloneState(decoded) };
+        return cloneState(cached.state);
     }
     return {
         async transact(fn) {
             assertCellOpen(closed);
             return withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
                 assertCellOpen(closed);
-                observe();
-                const current = readSquareFile(squarePath);
+                const current = currentState();
                 const working = cloneState(current);
                 const outcome = fn(working, version);
                 if (outcome.state !== undefined) {
                     writeSquareSnapshot(squarePath, outcome.state);
                     fingerprint = fileFingerprint(squarePath);
+                    cached = { fingerprint, state: cloneState(outcome.state) };
                     version += 1;
                 }
                 return outcome.result;
@@ -142,9 +153,7 @@ export function createFileCell(squarePath) {
         },
         async read() {
             assertCellOpen(closed);
-            observe();
-            const state = readSquareFile(squarePath);
-            return { state: cloneState(state), version };
+            return { state: currentState(), version };
         },
         async changed(sinceVersion, timeoutMs) {
             assertCellOpen(closed);

package/dist/views.d.ts

@@ -96,6 +96,7 @@ export declare function watchPresentation(square: OpenSquare, name: string): Pro
 export declare function inboxProjection(square: OpenSquare, name: string, ownerId: string): Promise<InboxProjection>;
 export declare function streamProjection(square: OpenSquare, cursor: number, recipient?: string): Promise<StreamProjection>;
 export declare function notificationForAct(square: OpenSquare, actIndex: number): Promise<readonly PlannedNotification[]>;
+export declare function pendingDeliveriesFromState(state: SquareState): readonly PendingDeliveryProjection[];
 export declare function pendingDeliveries(square: OpenSquare): Promise<readonly PendingDeliveryProjection[]>;
 export declare function notificationEvidence(square: OpenSquare, recipient: string, actIndex: number): Promise<{
     readonly delivered: boolean;

package/dist/views.js

@@ -78,6 +78,11 @@ export async function inboxProjection(square, name, ownerId) { const { state } =
 export async function streamProjection(square, cursor, recipient) { const { state } = await square.cell.read(); return { activities: state.acts.filter((activity) => activity.index > cursor).flatMap((activity) => { if (recipient === undefined)
         return [{ activity }]; const notification = planActNotifications(state, activity).find((candidate) => nameKey(candidate.recipient) === nameKey(recipient)); return notification === undefined ? [] : [{ activity, route: notification.route }]; }), cursor: Math.max(cursor, ...state.acts.map((activity) => activity.index)) }; }
 export async function notificationForAct(square, actIndex) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === actIndex); return activity === undefined ? [] : planActNotifications(state, activity); }
-export async function pendingDeliveries(square) { const { state } = await square.cell.read(); return [...new Set(state.acts.filter((activity) => activity.kind === 'join').map((activity) => activity.actor))].filter((name) => isCurrentlyJoined(state.acts, name)).map((recipient) => ({ recipient, notifications: deriveDeliveryModel(state).pendingFor(recipient) })); }
+export function pendingDeliveriesFromState(state) {
+    return [...new Set(state.acts.filter((activity) => activity.kind === 'join').map((activity) => activity.actor))]
+        .filter((name) => isCurrentlyJoined(state.acts, name))
+        .map((recipient) => ({ recipient, notifications: deriveDeliveryModel(state).pendingFor(recipient) }));
+}
+export async function pendingDeliveries(square) { const { state } = await square.cell.read(); return pendingDeliveriesFromState(state); }
 export async function notificationEvidence(square, recipient, actIndex) { const { state } = await square.cell.read(); return { delivered: isActivitySeen(state, recipient, actIndex), observation: observationFor(state, recipient, actIndex) }; }
 export async function notificationDelivered(square, recipient, actIndex) { const { state } = await square.cell.read(); return isActivitySeen(state, recipient, actIndex); }

package/dist/wake-evidence.d.ts

@@ -1,4 +1,5 @@
 import { type WakeRoute } from './model.js';
+import { type SquareState } from './model.js';
 import { type WakeAttempt } from './wake-attempts.js';
 export interface WakeEvidence {
     delivered: boolean;
@@ -8,6 +9,12 @@ export interface WakeEvidence {
     terminal?: WakeAttempt;
     attemptableRoutes: WakeRoute[];
 }
+export interface WakeEvidenceProjection {
+    evidence(recipient: string, actIndex: number): WakeEvidence;
+}
+/** Capture the primary wake facts once and derive any number of eligibility decisions from them. */
+export declare function wakeEvidenceProjection(squarePath: string, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidenceProjection>;
+export declare function wakeEvidenceProjectionFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv): WakeEvidenceProjection;
 /** Project every wake decision from the same primary evidence. */
 export declare function wakeEvidence(squarePath: string, recipient: string, actIndex: number, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidence>;
 export declare function wakeIsEligible(evidence: WakeEvidence): boolean;

package/dist/wake-evidence.js

@@ -1,38 +1,92 @@
-import { hasPresentedAttention } from './presented.js';
-import { lookupParticipant } from './registry.js';
+import { isActivitySeen } from './delivery.js';
+import { nameKey } from './model.js';
+import { readPresentedAttentions } from './presented.js';
+import { canonicalSquarePath, readActiveBindings } from './registry.js';
 import { readWakeRoutes } from './routes.js';
 import { isWakeRouteAttemptable, readWakeAttempts, terminalWakeEvidence, } from './wake-attempts.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { notificationEvidence } from './views.js';
-/** Project every wake decision from the same primary evidence. */
-export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {
+import { observationFor } from './runtime.js';
+import { entryPresentation } from './views.js';
+function attentionKey(squarePath, recipient, actIndex) {
+    return JSON.stringify([canonicalSquarePath(squarePath), nameKey(recipient), actIndex]);
+}
+function projectionFromState(squarePath, state, now, env) {
+    const canonicalPath = canonicalSquarePath(squarePath);
+    const owners = new Map();
+    for (const binding of readActiveBindings(now)) {
+        if (binding.squarePath !== canonicalPath)
+            continue;
+        const key = nameKey(binding.name);
+        const recipientOwners = owners.get(key) ?? new Set();
+        recipientOwners.add(binding.ownerId);
+        owners.set(key, recipientOwners);
+    }
+    const routesByOwner = new Map();
+    for (const route of readWakeRoutes({ freshOnly: true, now, env })) {
+        const routes = routesByOwner.get(route.ownerId) ?? [];
+        routes.push(route);
+        routesByOwner.set(route.ownerId, routes);
+    }
+    const attemptsByAttention = new Map();
+    for (const attempt of readWakeAttempts({ env, now })) {
+        const key = attentionKey(attempt.attention.squarePath, attempt.attention.recipient, attempt.attention.actIndex);
+        const attempts = attemptsByAttention.get(key) ?? [];
+        attempts.push(attempt);
+        attemptsByAttention.set(key, attempts);
+    }
+    const presentedByAttention = new Map();
+    for (const presented of readPresentedAttentions(env, now)) {
+        const key = attentionKey(presented.squarePath, presented.name, presented.actIndex);
+        const presentedOwners = presentedByAttention.get(key) ?? new Set();
+        presentedOwners.add(presented.ownerId);
+        presentedByAttention.set(key, presentedOwners);
+    }
+    return {
+        evidence(recipient, actIndex) {
+            const recipientOwners = owners.get(nameKey(recipient)) ?? new Set();
+            const key = attentionKey(squarePath, recipient, actIndex);
+            const attempts = attemptsByAttention.get(key) ?? [];
+            const terminal = terminalWakeEvidence(attempts);
+            const routes = [...recipientOwners].flatMap((ownerId) => routesByOwner.get(ownerId) ?? []);
+            const presented = [...(presentedByAttention.get(key) ?? [])]
+                .some((ownerId) => recipientOwners.has(ownerId));
+            return {
+                delivered: isActivitySeen(state, recipient, actIndex),
+                notified: (() => {
+                    const observation = observationFor(state, recipient, actIndex);
+                    return observation?.state === 'notified'
+                        && observation.ownerId !== undefined
+                        && recipientOwners.has(observation.ownerId);
+                })(),
+                presented,
+                attempts,
+                ...(terminal === undefined ? {} : { terminal }),
+                attemptableRoutes: terminal === undefined
+                    ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
+                    : [],
+            };
+        },
+    };
+}
+/** Capture the primary wake facts once and derive any number of eligibility decisions from them. */
+export async function wakeEvidenceProjection(squarePath, now, env) {
     const square = await openSquare(squarePath, { clock: () => now });
     try {
-        const { delivered, observation } = await notificationEvidence(square, recipient, actIndex);
-        const owners = new Set(lookupParticipant(squarePath, recipient, now).map((binding) => binding.ownerId));
-        const notified = observation?.state === 'notified'
-            && observation.ownerId !== undefined
-            && owners.has(observation.ownerId);
-        const attempts = readWakeAttempts({ attention: { squarePath, recipient, actIndex }, env, now });
-        const terminal = terminalWakeEvidence(attempts);
-        const routes = readWakeRoutes({ freshOnly: true, now, env })
-            .filter((route) => owners.has(route.ownerId));
-        return {
-            delivered,
-            notified,
-            presented: hasPresentedAttention(squarePath, recipient, actIndex, env, now),
-            attempts,
-            ...(terminal === undefined ? {} : { terminal }),
-            attemptableRoutes: terminal === undefined
-                ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
-                : [],
-        };
+        const { state } = await entryPresentation(square, '');
+        return projectionFromState(squarePath, state, now, env);
     }
     finally {
         await closeOpenSquare(square);
     }
 }
+export function wakeEvidenceProjectionFromState(squarePath, state, now, env) {
+    return projectionFromState(squarePath, state, now, env);
+}
+/** Project every wake decision from the same primary evidence. */
+export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {
+    return (await wakeEvidenceProjection(squarePath, now, env)).evidence(recipient, actIndex);
+}
 export function wakeIsEligible(evidence) {
     return !evidence.delivered
         && !evidence.notified

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {