@astrosheep/square 0.3.5 → 0.3.7

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

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"
@@ -15,7 +15,8 @@
   "interface": {
     "displayName": "Square",
     "shortDescription": "Join and coordinate through a shared square",
-    "longDescription": "Participate in a shared activity stream and receive addressed Square activity at Codex boundaries.",
+    "longDescription": "Participate in a shared square and receive addressed activity at Codex boundaries.",
+    "defaultPrompt": "Use Square to join other agents, catch their activity, express in words or embodied action, and step out when done.",
     "developerName": "Square",
     "category": "Developer Tools",
     "capabilities": [

package/codex-plugin/hooks/hooks.json

@@ -1,25 +1,14 @@
 {
   "hooks": {
-    "UserPromptSubmit": [
+    "PostToolUse": [
       {
         "hooks": [
           {
             "type": "command",
             "command": "square codex-hook",
             "timeout": 5,
-            "statusMessage": "square-codex-hook"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "square codex-hook",
-            "timeout": 5,
-            "statusMessage": "square-codex-hook"
+            "statusMessage": "square-codex-hook",
+            "additionalContextLimit": 1200
           }
         ]
       }

package/dist/activity-feed.js

@@ -1,36 +1,44 @@
 import { sameName } from './model.js';
-import { actStableIndex, advanceCursor, latestIndexedActIndex } from './runtime.js';
-import { matchesCatchFilter } from './delivery.js';
-export function indexedDelta(acts, cursor) {
-    return acts
-        .map((act) => ({ act, index: actStableIndex(act) }))
-        .filter((item) => item.index > cursor);
+import { advanceCursor, latestActIndex, readCursor } from './runtime.js';
+import { deriveDeliveryModel, matchesCatchFilter } from './delivery.js';
+export function actDelta(acts, cursor) {
+    return acts.filter((act) => act.index > cursor);
+}
+/** Public cursor changes plus directed receipts that remain pending behind it. */
+export function deliveryDelta(doc, name) {
+    const items = actDelta(doc.acts, readCursor(doc, name));
+    const seen = new Set(items.map((act) => act.index));
+    for (const notification of deriveDeliveryModel(doc).pendingFor(name)) {
+        if (!seen.has(notification.item.index))
+            items.push(notification.item);
+    }
+    return items.sort((a, b) => a.index - b.index);
 }
 export function peerRoomChanges(delta, name) {
-    return delta.filter((item) => item.act.actor !== undefined && !sameName(item.act.actor, name) && item.act.kind !== 'say' && item.act.kind !== 'read');
+    return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && act.kind !== 'say' && act.kind !== 'read');
 }
 export function peerPublicActs(delta, name) {
-    return delta.filter((item) => item.act.actor !== undefined && !sameName(item.act.actor, name) && (item.act.kind === 'say' || item.act.kind === 'done'));
+    return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && (act.kind === 'say' || act.kind === 'done'));
 }
-function matchesParticipants(item, participants) {
-    return participants === undefined || (item.act.actor !== undefined && participants.some((participant) => sameName(participant, item.act.actor)));
+function matchesParticipants(act, participants) {
+    return participants === undefined || (act.actor !== undefined && participants.some((participant) => sameName(participant, act.actor)));
 }
-export function matchesFeedFilter(item, filter) {
-    if (item.act.kind === 'say') {
-        return matchesCatchFilter({ actor: item.act.actor, body: item.act.body, bell: item.act.reach === 'bell' }, filter);
+export function matchesFeedFilter(act, filter) {
+    if (act.kind === 'say') {
+        return matchesCatchFilter({ actor: act.actor, body: act.body, reach: act.reach }, filter);
     }
-    return filter.mention === undefined && matchesParticipants(item, filter.participants);
+    return filter.mention === undefined && matchesParticipants(act, filter.participants);
 }
 export function filteredPeerActivities(delta, name, filter) {
     return peerPublicActs(delta, name)
-        .filter((item) => item.act.kind === 'say')
-        .filter((item) => matchesFeedFilter(item, filter));
+        .filter((act) => act.kind === 'say')
+        .filter((act) => matchesFeedFilter(act, filter));
 }
 export function filteredRoomChanges(delta, name, filter) {
     if (filter.mention !== undefined)
         return [];
-    return peerRoomChanges(delta, name).filter((item) => matchesParticipants(item, filter.participants));
+    return peerRoomChanges(delta, name).filter((act) => matchesParticipants(act, filter.participants));
 }
 export function ackPeerDelta(doc, name, delta) {
-    return advanceCursor(doc, name, latestIndexedActIndex([...peerPublicActs(delta, name), ...peerRoomChanges(delta, name)]), 'watch');
+    return advanceCursor(doc, name, latestActIndex([...peerPublicActs(delta, name), ...peerRoomChanges(delta, name)]));
 }

package/dist/activity.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { loadSquare } from './artifact.js';
 import { SquareError, validateName } from './model.js';
-import { actHintLine, renderActivityBlocked, renderActivityLimit, renderActNoWait, renderActWaiting, renderPendingFeed, withActivityNextOutput, } from './presentation.js';
+import { expressHintLine, renderActivityBlocked, renderActivityLimit, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, withPathOutput, } from './presentation.js';
 import { currentHold, inSquareCount, nowMs, SLEEP_MS, resolveRosterName } from './runtime.js';
 import { resolveKnownName } from './decisions.js';
 import { execute } from './square-application.js';
@@ -75,19 +75,19 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             force,
             now: nowMs(),
             ...(reach === undefined ? {} : { reach }),
+            ...(opts.reply === undefined ? {} : { reply: opts.reply }),
         });
         const decision = committed.result;
-        const sent = committed.acts[0];
         const freshDoc = loadSquare(squarePath);
         const headerCount = inSquareCount(freshDoc);
         const held = currentHold(freshDoc.acts).active;
         switch (decision.type) {
             case 'sent': {
                 const hasPending = decision.pendingPublic.length > 0 || decision.pendingRoomChanges.length > 0;
-                const pending = hasPending ? `\n\n${renderPendingFeed(decision.pendingPublic, decision.pendingRoomChanges)}` : '';
-                const hint = actHintLine(decision.ownActCount);
+                const pending = hasPending ? `\n\n${renderPendingFeed(freshDoc.acts, decision.pendingPublic, decision.pendingRoomChanges)}` : '';
+                const hint = expressHintLine(decision.ownActCount);
                 const withHint = hint ? `${decision.confirmation}\n${hint}` : decision.confirmation;
-                process.stdout.write(withActivityNextOutput(squarePath, withHint + pending, { participantCount: headerCount, held }));
+                process.stdout.write(withPathOutput(squarePath, withHint + pending, { participantCount: headerCount, held }));
                 return;
             }
             case 'blocked': {
@@ -121,11 +121,11 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             case 'throttled': {
                 if (noWait) {
                     const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                    process.stdout.write(renderActNoWait({ squarePath, name: knownName, reason: 'throttled', delayMs: decision.delayMs, draftPath, participantCount: headerCount, held }));
+                    process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'throttled', delayMs: decision.delayMs, draftPath, participantCount: headerCount, held }));
                     process.exit(1);
                 }
                 if (announcedWait !== 'throttled') {
-                    process.stdout.write(renderActWaiting({ reason: 'throttled', delayMs: decision.delayMs }) + '\n');
+                    process.stdout.write(renderExpressWaiting({ reason: 'throttled', delayMs: decision.delayMs }) + '\n');
                     announcedWait = 'throttled';
                 }
                 await sleep(decision.delayMs);
@@ -134,18 +134,18 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             case 'held': {
                 if (noWait) {
                     const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                    process.stdout.write(renderActNoWait({ squarePath, name: knownName, reason: 'held', holdReason: decision.reason, draftPath, participantCount: headerCount, held }));
+                    process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'held', holdReason: decision.reason, draftPath, participantCount: headerCount, held }));
                     process.exit(1);
                 }
                 if (announcedWait !== 'held') {
-                    process.stdout.write(renderActWaiting({ reason: 'held' }) + '\n');
+                    process.stdout.write(renderExpressWaiting({ reason: 'held' }) + '\n');
                     announcedWait = 'held';
                 }
                 await sleep(SLEEP_MS);
                 break;
             }
             case 'bell_quota': {
-                process.stdout.write(withActivityNextOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(decision.nextAt)}`].join('\n'), { participantCount: headerCount, held }));
+                process.stdout.write(withPathOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(decision.nextAt)}`].join('\n'), { participantCount: headerCount, held }));
                 process.exit(1);
             }
         }