@astrosheep/square 0.3.50 → 0.3.52

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

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.50",
+  "version": "0.3.52",
   "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.50",
+  "version": "0.3.52",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/attention-presentation.d.ts

@@ -7,8 +7,8 @@ export interface AttentionPreview {
     actor: string;
     route: DirectedNotificationRoute;
     body: string;
-    compact?: boolean;
 }
 export declare function previewAttentionBody(body: string): string;
+export declare function attentionBodyIsClipped(body: string): boolean;
 export declare function displayAttentionPath(squarePath: string): string;
 export declare function renderAttentionPreview(attention: AttentionPreview): string;

package/dist/attention-presentation.js

@@ -1,7 +1,6 @@
 import { homedir } from 'node:os';
-import { notificationMessageId } from './delivery.js';
-import { participantIdentity } from './presentation.js';
 import { formatActivityId } from './square-core.js';
+import { participantCommandPrefix } from './presentation.js';
 export const ATTENTION_BODY_MAX = 200;
 export function previewAttentionBody(body) {
     const compact = body.replace(/\r\n/g, '\n');
@@ -9,6 +8,9 @@ export function previewAttentionBody(body) {
         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 displayAttentionPath(squarePath) {
     return squarePath.startsWith(homedir())
         ? `~${squarePath.slice(homedir().length)}`
@@ -16,12 +18,25 @@ export function displayAttentionPath(squarePath) {
 }
 export function renderAttentionPreview(attention) {
     const attentionKind = attention.route === 'bell' ? 'bell' : 'attention';
-    const id = attention.compact
-        ? formatActivityId(attention.actIndex)
-        : `${notificationMessageId(attention.squarePath, attention.actIndex)} · ${displayAttentionPath(attention.squarePath)}`;
-    const normalizedBody = attention.body.replace(/\r\n/g, '\n');
+    const attributes = {
+        location: displayAttentionPath(attention.squarePath),
+        id: formatActivityId(attention.actIndex),
+        from: attention.actor,
+        to: attention.recipient,
+        kind: attentionKind,
+    };
     return [
-        `${id}: ${participantIdentity(attention.recipient)} from ${participantIdentity(attention.actor)} (${attentionKind})`,
-        previewAttentionBody(normalizedBody),
+        '<square-activity',
+        ...Object.entries(attributes).map(([key, value]) => `  ${key}="${escapeAttribute(value)}"`),
+        '>',
+        previewAttentionBody(attention.body),
+        '</square-activity>',
+        ...(attentionBodyIsClipped(attention.body)
+            ? [`» ${participantCommandPrefix(attention.squarePath, attention.recipient)} catch --id ${formatActivityId(attention.actIndex)}`]
+            : []),
     ].join('\n');
 }
+function escapeAttribute(value) {
+    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+        .replace(/\r/g, '&#13;').replace(/\n/g, '&#10;').replace(/\t/g, '&#9;');
+}

package/dist/boundary-presentation.js

@@ -6,8 +6,10 @@ import { withFileLock } from './file-lock.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { presentPending } from './presentation-operations.js';
-import { sessionInbox } from './inbox.js';
-import { renderAttentionPreview } from './attention-presentation.js';
+import { hostLedgerForEnv, sessionInbox } from './inbox.js';
+import { attentionBodyIsClipped, renderAttentionPreview } from './attention-presentation.js';
+import { presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
+import { formatActivityId } from './square-core.js';
 const CONTEXT_MAX = 1200;
 const presentationLocks = new Map();
 function pendingCount(inbox) {
@@ -34,10 +36,6 @@ function frameBoundary(lines) {
     return `\n${lines.join('\n')}\n`;
 }
 function renderBoundary(inbox) {
-    const count = pendingCount(inbox);
-    const noun = count === 1 ? 'notification' : 'notifications';
-    const header = `<system-reminder source="square">You have ${count} Square ${noun}.`;
-    const footer = ['</system-reminder>'];
     const queued = inbox.flatMap((membership) => membership.notifications.map((notification) => ({ membership, notification })));
     const blocks = [];
     const complete = [];
@@ -55,15 +53,7 @@ function renderBoundary(inbox) {
             }),
         ].join('\n');
         const omittedAfter = omitted + queued.length - index - 1;
-        const prospective = frameBoundary([
-            header,
-            ...blocks,
-            block,
-            ...(omittedAfter > 0
-                ? [`… ${omittedAfter} ${omittedAfter === 1 ? 'notification' : 'notifications'} omitted.`]
-                : []),
-            ...footer,
-        ]);
+        const prospective = frameBoundary([...blocks, block, ...(omittedAfter > 0 ? [`… ${omittedAfter} ${omittedAfter === 1 ? 'notification' : 'notifications'} omitted.`] : [])]);
         if (prospective.length > CONTEXT_MAX) {
             omitted += 1;
             continue;
@@ -72,20 +62,11 @@ function renderBoundary(inbox) {
         complete.push({
             membership,
             actIndexes: [notification.actIndex],
-            // The hook output is itself a user-visible presentation, even when the
-            // preview had to clip the body. Keep clipped items from being replayed.
-            markSeen: true,
+            markSeen: !attentionBodyIsClipped(notification.body),
         });
     }
     return {
-        context: frameBoundary([
-            header,
-            ...blocks,
-            ...(omitted > 0
-                ? [`… ${omitted} ${omitted === 1 ? 'notification' : 'notifications'} omitted.`]
-                : []),
-            ...footer,
-        ]),
+        context: frameBoundary([...blocks, ...(omitted > 0 ? [`… ${omitted} ${omitted === 1 ? 'notification' : 'notifications'} omitted.`] : [])]),
         complete,
     };
 }
@@ -93,7 +74,17 @@ async function presentPendingAtBoundaryUnlocked(sessionId, present, lookup = ses
     const inbox = await lookup(sessionId, env);
     if (signal?.aborted)
         return undefined;
-    const delivered = renderBoundary(pendingAtBoundary(inbox));
+    const hostLedger = hostLedgerForEnv(env);
+    const pending = [];
+    for (const membership of pendingAtBoundary(inbox)) {
+        const evidence = await projectPresentationEvidence({ hostLedger, location: membership.squarePath, participant: membership.name, sessionId });
+        const notifications = membership.notifications.filter((notification) => !presentationSuppressesWake(evidence.filter((row) => row.activity === formatActivityId(notification.actIndex))));
+        if (notifications.length > 0)
+            pending.push({ ...membership, notifications });
+    }
+    if (pending.length === 0 || signal?.aborted)
+        return undefined;
+    const delivered = renderBoundary(pending);
     if (delivered.context === '')
         return undefined;
     let result;

package/dist/cli/observation-commands.js

@@ -467,13 +467,7 @@ export const statusCommand = {
         try {
             const presentation = await statusPresentation(square);
             const result = presentation.status;
-            const active = result.participants.filter((participant) => participant.state === 'active').sort((a, b) => {
-                const aViewer = context.name !== undefined && sameName(a.name, context.name);
-                const bViewer = context.name !== undefined && sameName(b.name, context.name);
-                if (aViewer !== bViewer)
-                    return aViewer ? -1 : 1;
-                return (b.lastActiveAt ?? -Infinity) - (a.lastActiveAt ?? -Infinity) || a.name.localeCompare(b.name);
-            });
+            const active = result.participants.filter((participant) => participant.state === 'active');
             const people = active.length === 0 ? ['  ○ nobody in the square'] : active.slice(0, STATUS_PARTICIPANT_PREVIEW_LIMIT).map((participant) => {
                 const glyph = participant.presence === 'watching'
                     ? '◎'

package/dist/decisions.d.ts

@@ -90,11 +90,11 @@ export interface ParticipantStatus {
     activityCount: number;
     lastActiveAt: number | undefined;
     presence: CorePresenceState;
-    presenceAt: number | undefined;
     unreadActivityCount: number;
     pendingMentionCount: number;
 }
 export type CorePresenceState = 'never-joined' | 'active' | 'watching' | 'done';
+export declare function compareParticipantActivity(a: Pick<ParticipantStatus, 'name' | 'lastActiveAt'>, b: Pick<ParticipantStatus, 'name' | 'lastActiveAt'>): number;
 export interface StatusResult {
     hardCap: HardCap;
     throttlePerMinute: number | undefined;

package/dist/decisions.js

@@ -212,23 +212,23 @@ export function coreResume(squareState, actor, now) {
     requireStanding(squareState, act);
     return act;
 }
-function presenceFor(squareState, snapshot, name, now, delivery) {
-    if (snapshot?.done)
-        return { state: 'done', lastAt: snapshot.lastActiveAt };
-    const cursorAt = squareState.acts.findLast((act) => act.index <= delivery.cursorFor(name))?.at;
-    const lease = freshWatchLease(squareState, name, now);
-    if (lease !== undefined)
-        return { state: 'watching', lastAt: cursorAt ?? lease.heartbeatAt };
-    const lastAt = cursorAt ?? (snapshot?.joined ? snapshot.lastActiveAt : undefined);
-    return lastAt === undefined
-        ? { state: 'never-joined', lastAt: undefined }
-        : { state: 'active', lastAt };
+export function compareParticipantActivity(a, b) {
+    return (b.lastActiveAt ?? -Infinity) - (a.lastActiveAt ?? -Infinity) || a.name.localeCompare(b.name);
 }
 function buildParticipantStatuses(squareState, now, state = foldedState(squareState), suppliedDelivery) {
     const delivery = suppliedDelivery ?? deriveDeliveryModel(squareState);
     return state.participants.map((snapshot) => {
         const participant = snapshot.name;
-        const presence = presenceFor(squareState, snapshot, participant, now, delivery);
+        let lastActiveAt = snapshot.lastActiveAt;
+        // Receipt time is evidence of catching; the consumed activity's time is not.
+        if (snapshot.joined) {
+            for (const observation of Object.values(squareState.runtime.observations[participant] ?? {})) {
+                if (observation.state === 'seen')
+                    lastActiveAt = Math.max(lastActiveAt ?? -Infinity, observation.at);
+            }
+        }
+        const presence = snapshot.done ? 'done' : !snapshot.joined ? 'never-joined'
+            : freshWatchLease(squareState, participant, now) !== undefined ? 'watching' : 'active';
         const participantStatus = snapshot?.done ? 'done' : snapshot?.joined ? 'active' : 'not joined';
         const consumedThrough = delivery.cursorFor(participant);
         let unreadActivityCount = 0;
@@ -245,13 +245,12 @@ function buildParticipantStatuses(squareState, now, state = foldedState(squareSt
             state: participantStatus,
             listening: listeningTo(state, participant),
             activityCount: snapshot?.activityCount ?? 0,
-            lastActiveAt: snapshot?.lastActiveAt,
-            presence: presence.state,
-            presenceAt: presence.lastAt,
+            lastActiveAt,
+            presence,
             unreadActivityCount,
             pendingMentionCount: snapshot?.joined ? delivery.pendingFor(participant).length : 0,
         };
-    });
+    }).sort(compareParticipantActivity);
 }
 export function coreStatus(squareState, now, delivery) {
     const state = foldedState(squareState);

package/dist/inbox.d.ts

@@ -1,4 +1,5 @@
 import { type InboxMembership } from './model.js';
+export declare function hostLedgerForEnv(env: NodeJS.ProcessEnv): import("./host-ledger.js").HostLedgerPort;
 export interface PendingWaitOptions {
     signal?: AbortSignal;
     /** Ephemeral watcher de-duplication; never persisted or used by delivery derivation. */

package/dist/inbox.js

@@ -4,7 +4,7 @@ import { waitForSquareChanges } from './square-file-adapter.js';
 import path from 'node:path';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { projectPresentation, projectSessionBindings } from './square-projections.js';
-function hostLedgerForEnv(env) {
+export function hostLedgerForEnv(env) {
     const root = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
     return createHostLedgerPort({
         userPath: env.SQUARE_HOST_LEDGER_USER ?? root,

package/dist/presentation.js

@@ -7,6 +7,7 @@ import { audienceIncludes, audienceOf, MAX_IDENTITY_SET_SIZE } from './square-co
 import { perceiveActivity } from './delivery.js';
 import { actId, publicActs, readCursor, rosterNames, sayNumberFor } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
+import { compareParticipantActivity } from './decisions.js';
 import { grepSnippet } from './search.js';
 function headerLine(squarePath, opts = {}) {
     const count = opts.participantCount ?? 0;
@@ -56,7 +57,7 @@ function presenceGlyph(participant) {
         return '○';
     if (participant.presence === 'watching')
         return '◎';
-    if (participant.presenceAt !== undefined)
+    if (participant.lastActiveAt !== undefined)
         return '●';
     return '○';
 }
@@ -65,19 +66,17 @@ function presenceText(participant, now) {
         return participant.lastActiveAt === undefined ? 'stepped out of the square' : `stepped out of the square · ${formatRelativeTime(participant.lastActiveAt, now)}`;
     }
     if (participant.presence === 'watching') {
-        const at = participant.presenceAt ?? participant.lastActiveAt;
+        const at = participant.lastActiveAt;
         return at === undefined ? 'catching' : `catching · ${formatRelativeTime(at, now)}`;
     }
-    if (participant.presenceAt === undefined)
+    if (participant.lastActiveAt === undefined)
         return 'quiet';
-    return participant.activityCount > 0 ? `${formatRelativeTime(participant.presenceAt, now)}` : `quiet · ${formatRelativeTime(participant.presenceAt, now)}`;
+    return participant.activityCount > 0 ? `${formatRelativeTime(participant.lastActiveAt, now)}` : `quiet · ${formatRelativeTime(participant.lastActiveAt, now)}`;
 }
 export function renderPresenceLines(participants, now, limit = 5) {
     const recent = participants
-        .map((p) => ({ p, at: p.presenceAt ?? p.lastActiveAt ?? -Infinity }))
-        .filter(({ p, at }) => p.state === 'done' || p.presence === 'watching' || (at !== -Infinity && now - at <= PRESENCE_WINDOW_MS))
-        .sort((a, b) => b.at - a.at || a.p.name.localeCompare(b.p.name))
-        .map(({ p }) => p);
+        .filter((p) => p.state === 'done' || p.presence === 'watching' || (p.lastActiveAt !== undefined && now - p.lastActiveAt <= PRESENCE_WINDOW_MS))
+        .sort(compareParticipantActivity);
     const shown = recent.slice(0, limit);
     if (shown.length === 0)
         return ['  ○ nobody nearby'];
@@ -90,8 +89,7 @@ export function renderPresenceLines(participants, now, limit = 5) {
 const EXPRESS_HINTS = [
     '*asterisks* are your body — *slams table*, *sketches in the air*, *shrugs*',
     "you're standing in a square — words and gestures both land",
-    'half-shaped is welcome — a sketch, an objection, a joke, a fragment',
-    '@ only who you need — step back with catch --mention',
+    'the square is for conversation — share thoughts and engage with others, beyond status updates and empty acknowledgments',
 ];
 export function expressHintLine(ownActivityCount) {
     if (ownActivityCount !== 1 && ownActivityCount % 5 !== 0)

package/dist/square-core.js

@@ -150,19 +150,20 @@ function applyActivity(accumulator, act) {
     const { state, byKey, ordered } = accumulator;
     const actor = actorOf(act);
     const snapshot = actor === undefined ? undefined : touchParticipant(byKey, ordered, actor);
+    if (snapshot !== undefined && act.at !== undefined) {
+        snapshot.lastActiveAt = Math.max(snapshot.lastActiveAt ?? -Infinity, act.at);
+    }
     switch (act.kind) {
         case 'join':
             if (snapshot !== undefined) {
                 snapshot.joined = true;
                 snapshot.done = false;
-                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
             }
             break;
         case 'done':
             if (snapshot !== undefined) {
                 snapshot.joined = false;
                 snapshot.done = true;
-                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
                 state.listening.delete(nameKey(snapshot.name));
             }
             break;
@@ -195,7 +196,6 @@ function applyActivity(accumulator, act) {
         case 'say':
             if (snapshot !== undefined) {
                 snapshot.activityCount += 1;
-                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
             }
             pushThrottleAt(state, act.at);
             if (act.reach === 'bell')

package/dist/views.js

@@ -68,7 +68,7 @@ export async function activityPresentation(square, name) { const { state } = awa
 export async function entryPresentation(square, name, lastN = 10) { const { state } = await square.artifact.read(); const known = resolveRosterName(state, name) ?? name; const publicActivities = state.acts.filter((activity) => activity.kind === 'say' || activity.kind === 'done'); return { joined: isCurrentlyJoined(state.acts, known), scene: state.warmup.join('\n').trim(), context: state.preamble.join('\n').trim(), joinContext: (state.preamble.at(-1) === '---' ? state.preamble.slice(0, -1) : state.preamble).join('\n').trim(), recentActivities: lastN === null ? publicActivities : publicActivities.slice(-lastN), state, sayNumbers: sayNumbers(state), participantCount: inSquareCount(state) }; }
 export async function historyPresentation(square, options) { const { state } = await square.artifact.read(); const delivery = deriveDeliveryModel(state); return { activities: coreActivities(state, options, delivery), sayNumbers: sayNumbers(state), presenceAnchors: anchors(state, delivery), participantCount: inSquareCount(state) }; }
 export async function participantsPresentation(square) { const { state } = await square.artifact.read(); const delivery = deriveDeliveryModel(state); return coreParticipants(state, square.clock(), delivery); }
-export async function listPresentation(square) { const { state } = await square.artifact.read(); return { context: state.preamble, participants: foldedState(state).participants.filter((participant) => participant.joined).sort((left, right) => (right.lastActiveAt ?? -Infinity) - (left.lastActiveAt ?? -Infinity) || left.name.localeCompare(right.name)).map((participant) => participant.name), activities: state.acts.filter((activity) => activity.kind === 'say').length }; }
+export async function listPresentation(square) { const { state } = await square.artifact.read(); return { context: state.preamble, participants: coreParticipants(state, square.clock()).filter((participant) => participant.state === 'active').map((participant) => participant.name), activities: state.acts.filter((activity) => activity.kind === 'say').length }; }
 export async function statusPresentation(square) { const { state } = await square.artifact.read(); const delivery = deriveDeliveryModel(state); const status = coreStatus(state, square.clock(), delivery); return { state, status, ...(status.latestAct?.kind === 'say' ? { latestActNumber: countSays(state.acts, status.latestAct.actor) } : {}) }; }
 export async function eventPresentation(square, id) { const { state } = await square.artifact.read(); const activity = state.acts.find((candidate) => candidate.index === parseRequiredActivityId(id)); if (activity === undefined)
     throw new SquareError('invalid_args', `Unknown activity id: ${id}`); return { activity, participantCount: inSquareCount(state), held: currentHold(state.acts).active }; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.50",
+  "version": "0.3.52",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     "clean": "node --input-type=module -e \"import fs from 'node:fs'; fs.rmSync('dist',{recursive:true,force:true})\"",
     "build": "npm run clean && tsc && node --input-type=module -e \"import fs from 'node:fs'; fs.chmodSync('dist/square.js',0o755)\"",
     "verify-release": "node test/release.test.js",
+    "release": "npm version patch && npm publish && git push --follow-tags",
     "prepublishOnly": "npm run build && npm run verify-release",
     "test": "npm run build && node --test test/*.test.js",
     "test:cli-process": "npm run build && node --test test/process/square-cli-render.test.js"