@astrosheep/square 0.3.30 → 0.3.32

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

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

package/claude-plugin/hooks/hooks.json

@@ -4,9 +4,6 @@
     "SessionStart": [
       { "hooks": [{ "type": "command", "command": "square claude-hook", "timeout": 5 }] }
     ],
-    "SessionResume": [
-      { "hooks": [{ "type": "command", "command": "square claude-hook", "timeout": 5 }] }
-    ],
     "SessionEnd": [
       { "hooks": [{ "type": "command", "command": "square claude-hook", "timeout": 5 }] }
     ],

package/claude-plugin/skills/square/SKILL.md

@@ -61,7 +61,7 @@ The ownership boundary belongs here. @bob, does this match your read?
 EOF
 ```
 
-**Addressing.** Normally address whoever needs the activity with `@name`: mentioned participants hear the full body even when they are not listening, and everyone else sees you walk over to them. A bare activity (no mention) lands in history whether or not anyone is listening; `listen` only opts a participant into future bare delivery. Use `--bell` only when every participant needs it. Addressing is not a secrecy boundary — precise `history` queries and `history --all --full` read original bodies.
+**Addressing.** Normally address whoever needs the activity with `@name`: mentioned participants hear the full body even when they are not listening, and everyone else sees you walk over to them. A bare activity (no mention) lands in history whether or not anyone is listening; `listen` only opts a participant into future bare delivery. Use `--bell` only when every participant needs it. Addressing is not a secrecy boundary — `history` is a read-only archive with stable activity-id cursors.
 
 **Discipline.** Every activity counts against your cap and the square's throttle, so make each one worth landing. Keep private progress and tool chatter out — express only when another participant needs the thought, question, or decision.
 
@@ -98,13 +98,14 @@ square --location <square> --as <name> ignore <participant>
 
 ```bash
 square history --limit 5               # most recent 5, oldest to newest
+square history --before act/12 --limit 5 # the page before act/12
+square history --after act/12 --limit 5  # the page after act/12
 square history --limit 5 --order desc  # newest first
-square history --all                   # every entry
-square history --full                  # expand bodies in range
+square history --no-truncate           # expand preview bodies
 square history --grep 'term'           # search
 ```
 
-See `square history --help` for advanced usage. Never read or parse the binary Square artifact directly; use `history --all --full` for the complete record.
+See `square history --help` for advanced usage. Never read or parse the binary Square artifact directly. Bodies are previews by default; follow the printed activity-id command to continue page by page.
 
 ## Hold
 

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

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

package/dist/activity.js

@@ -5,13 +5,14 @@ import { setTimeout as sleep } from 'node:timers/promises';
 import { SquareError, isSquareError, validateName } from './model.js';
 import { expressHintLine, renderActivityBlocked, renderActivityLimit, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, withPathOutput, } from './presentation.js';
 import { nowMs, SLEEP_MS } from './runtime.js';
-import { wakeNotifierForSquare } from './notifications.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { Square } from './square-wiring.js';
 import { activityPresentation, resolveParticipant } from './views.js';
 import { formatActivityId } from './square-core.js';
 import { formatTimestamp } from './time.js';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
+import { createDefaultWakeTransport } from './notifications.js';
 function draftDirFor(squarePath) {
     return path.join(path.dirname(squarePath), 'drafts');
 }
@@ -67,7 +68,9 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
     const noWait = opts.noWait ?? false;
     const reach = opts.reach === 'bell' ? 'bell' : undefined;
     let announcedWait;
-    const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
+    const ledgerRoot = process.env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(process.env.SQUARE_REGISTRY);
+    const hostLedger = createHostLedgerPort({ userPath: process.env.SQUARE_HOST_LEDGER_USER ?? ledgerRoot, localPath: process.env.SQUARE_HOST_LEDGER_LOCAL ?? ledgerRoot });
+    const square = await Square.at({ path: squarePath, clock: nowMs, hostLedger, wakeTransport: await createDefaultWakeTransport(hostLedger, nowMs) });
     try {
         const participant = await square.join(name);
         while (true) {
@@ -76,11 +79,13 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             const pendingPublic = before.pendingPublic;
             const pendingRoomChanges = before.pendingRoomChanges;
             try {
-                await participant.express(body, {
+                const result = await participant.express(body, {
                     force,
                     ...(reach === undefined ? {} : { reach }),
                     ...(opts.reply === undefined ? {} : { reply: formatActivityId(opts.reply) }),
                 });
+                if (result.delivery?.notCapable)
+                    process.stderr.write(`! wake not-capable: ${result.delivery.notCapable}\n`);
                 const freshSquare = await openSquare(squarePath, { clock: nowMs });
                 const fresh = await activityPresentation(freshSquare, knownName).finally(() => closeOpenSquare(freshSquare));
                 const headerCount = fresh.participantCount;

package/dist/artifact.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { TextDecoder } from 'node:util';
 import zlib from 'node:zlib';
-import { isWakeRouteKind, InternalSquareError, nameKey, SquareError, } from './model.js';
+import { isWakeRouteKind, InternalSquareError, SquareError, } from './model.js';
 import { parseActivityId } from './square-core.js';
 const SQUARE_MAGIC = Buffer.from('SQUARE01', 'ascii');
 const LENGTH_BYTES = 4;
@@ -37,16 +37,14 @@ function isStringArray(value) {
 }
 function validateObservation(value) {
     return isObject(value)
-        && hasExactKeys(value, ['state', 'at'], ['ownerId'])
-        && (value.state === 'notified' || value.state === 'seen')
-        && isFiniteNumber(value.at)
-        && (value.ownerId === undefined || isNonblankString(value.ownerId));
+        && hasExactKeys(value, ['state', 'at'])
+        && value.state === 'seen'
+        && isFiniteNumber(value.at);
 }
 function validateWatchLease(value) {
     if (!isObject(value)
-        || !hasExactKeys(value, ['leaseId', 'heartbeatAt', 'expiresAt'], ['ownerId', 'filter'])
+        || !hasExactKeys(value, ['leaseId', 'heartbeatAt', 'expiresAt'], ['filter'])
         || !isNonblankString(value.leaseId)
-        || (value.ownerId !== undefined && !isNonblankString(value.ownerId))
         || !isFiniteNumber(value.heartbeatAt)
         || !isFiniteNumber(value.expiresAt)
         || value.expiresAt < value.heartbeatAt)
@@ -58,49 +56,16 @@ function validateWatchLease(value) {
         && (value.filter.participants === undefined || isStringArray(value.filter.participants))
         && (value.filter.mention === undefined || typeof value.filter.mention === 'string');
 }
-function validateNotifyLease(value) {
-    if (!isObject(value)
-        || !hasExactKeys(value, ['leaseId', 'expiresAt', 'phase'], ['attemptN', 'routeKind'])
-        || !isNonblankString(value.leaseId)
-        || !isFiniteNumber(value.expiresAt)
-        || (value.phase !== 'claimed' && value.phase !== 'dispatching')
-        || (value.attemptN !== undefined && (!Number.isSafeInteger(value.attemptN) || value.attemptN <= 0))
-        || (value.routeKind !== undefined && !isWakeRouteKind(value.routeKind)))
-        return false;
-    return value.phase !== 'dispatching' || (value.attemptN !== undefined && value.routeKind !== undefined);
-}
 function validateRecord(value, item) {
     return isObject(value)
         && Object.entries(value).every(([key, candidate]) => key.length > 0 && item(candidate));
 }
-function parseNotifyLeaseKey(key) {
-    let parsed;
-    try {
-        parsed = JSON.parse(key);
-    }
-    catch {
-        return undefined;
-    }
-    if (!Array.isArray(parsed) || parsed.length !== 2)
-        return undefined;
-    const [id, name] = parsed;
-    if (typeof id !== 'string' || typeof name !== 'string' || name.length === 0 || nameKey(name) !== name) {
-        return undefined;
-    }
-    const index = parseActivityId(id);
-    if (index === undefined)
-        return undefined;
-    if (JSON.stringify([id, name]) !== key)
-        return undefined;
-    return { index, name };
-}
 function validateRuntime(value) {
     if (!isObject(value)
-        || !hasExactKeys(value, ['nextActIndex', 'observations', 'leases', 'notifyLeases'])
+        || !hasExactKeys(value, ['nextActIndex', 'observations', 'leases'])
         || !isNonNegativeInteger(value.nextActIndex)
         || !validateRecord(value.observations, (candidate) => isObject(candidate) && Object.entries(candidate).every(([id, observation]) => parseActivityId(id) !== undefined && validateObservation(observation)))
-        || !validateRecord(value.leases, validateWatchLease)
-        || !validateRecord(value.notifyLeases, validateNotifyLease))
+        || !validateRecord(value.leases, validateWatchLease))
         return false;
     return true;
 }
@@ -115,13 +80,6 @@ function validateAssignedRuntimeReferences(runtime) {
                 return 'future';
         }
     }
-    for (const key of Object.keys(runtime.notifyLeases)) {
-        const parsed = parseNotifyLeaseKey(key);
-        if (parsed === undefined)
-            return 'malformed';
-        if (parsed.index >= bound)
-            return 'future';
-    }
     return 'ok';
 }
 function validateActor(value, required) {
@@ -180,13 +138,14 @@ function validateActs(value) {
 }
 function validateSquareState(value) {
     if (!isObject(value)
-        || !hasExactKeys(value, ['hardCap', 'preamble', 'warmup', 'acts', 'runtime'], ['throttlePerMinute'])
+        || !hasExactKeys(value, ['hardCap', 'preamble', 'warmup', 'acts', 'runtime'], ['throttlePerMinute', 'routes'])
         || !(value.hardCap === null || (Number.isSafeInteger(value.hardCap) && value.hardCap > 0))
         || (value.throttlePerMinute !== undefined
             && (!Number.isSafeInteger(value.throttlePerMinute) || value.throttlePerMinute <= 0))
         || !isStringArray(value.preamble)
         || !isStringArray(value.warmup)
         || !validateActs(value.acts)
+        || (value.routes !== undefined && (!Array.isArray(value.routes) || !value.routes.every((route) => isObject(route) && isWakeRouteKind(route.kind) && typeof route.location === 'string' && typeof route.participant === 'string' && typeof route.sessionId === 'string' && typeof route.channel === 'string' && isObject(route.address) && Object.values(route.address).every((item) => typeof item === 'string') && typeof route.updatedAt === 'number')))
         || !validateRuntime(value.runtime)) {
         throw invalidArtifact('snapshot schema is malformed.');
     }
@@ -253,7 +212,6 @@ export function emptyRuntimeState(nextActIndex = 0) {
         nextActIndex,
         observations: {},
         leases: {},
-        notifyLeases: {},
     };
 }
 function normalizedLines(value) {
@@ -284,6 +242,7 @@ export function createSquareState(options, snippet) {
         preamble: normalizedLines(snippet),
         warmup: normalizedLines(guides.join('\n\n')),
         acts: [],
+        routes: [],
         runtime: emptyRuntimeState(),
     };
 }

package/dist/automatic-session.js

@@ -4,8 +4,10 @@ import { openSquare } from './square-file-adapter.js';
 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 { automaticParticipant } from './participant-identity.js';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
+import { projectSessionBindings } from './square-projections.js';
+import { publishWakeRoute, retireWakeRouteFromArtifact, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
 export { automaticParticipant } from './participant-identity.js';
 const providerEnv = {
     codex: 'CODEX_THREAD_ID',
@@ -13,6 +15,16 @@ const providerEnv = {
     opencode: 'OPENCODE_SESSION_ID',
     pi: 'SQUARE_PI_SESSION_ID',
 };
+function operationEnv(provider, sessionId, env) {
+    return { ...env, [providerEnv[provider]]: sessionId };
+}
+function hostLedgerForEnv(env) {
+    const root = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
+    return createHostLedgerPort({
+        userPath: env.SQUARE_HOST_LEDGER_USER ?? root,
+        localPath: env.SQUARE_HOST_LEDGER_LOCAL ?? root,
+    });
+}
 export function publicSquarePath(cwd) {
     return path.join(cwd, '.square', 'PUBLIC.square');
 }
@@ -38,16 +50,25 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         return undefined;
     }
     const name = automaticParticipant(provider, sessionId, env);
-    const canonicalPath = await canonicalSquarePath(squarePath);
-    const alreadyBound = (await lookupSessionBindings(sessionId)).some((binding) => binding.squarePath === canonicalPath && binding.name === name);
     await closeOpenSquare(reader);
-    const square = await Square.at({ path: squarePath });
+    const scopedEnv = operationEnv(provider, sessionId, env);
+    const square = await Square.at({ path: squarePath, hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv });
     try {
         const implicit = await square.implicitJoin(name);
-        if (implicit.state === 'done' || (implicit.state === 'active' && alreadyBound))
+        if (implicit.state === 'done')
             return undefined;
-        const channel = provider === 'claude' ? 'claude-code' : provider;
-        await recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
+        const route = resolvePrimaryWakeRoute({ location: squarePath, participant: name, sessionId, provider }, env, await defaultWakeRouteCapabilities(hostLedgerForEnv(env)));
+        if (route !== undefined) {
+            const publisher = await openSquare(squarePath, { hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv });
+            try {
+                await publishWakeRoute(publisher.artifact, route, { at: Date.now() });
+            }
+            finally {
+                await closeOpenSquare(publisher);
+            }
+        }
+        await hostLedgerForEnv(env).ensurePresence({ location: squarePath, participant: name, session: sessionId, channel: provider === 'claude' ? 'claude-code' : provider, updatedAt: Date.now() }, 'user');
+        await square.reconcileBinding();
         return undefined;
     }
     finally {
@@ -56,22 +77,36 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
 }
 export async function automaticSessionEnd(provider, sessionId, cwd, env = process.env) {
     const squarePath = publicSquarePath(cwd);
-    const channel = provider === 'claude' ? 'claude-code' : provider;
-    const canonicalPath = await canonicalSquarePath(squarePath);
-    const binding = (await lookupSessionBindings(sessionId)).find((item) => item.squarePath === canonicalPath && item.channel === channel);
+    const scopedEnv = operationEnv(provider, sessionId, env);
+    const hostLedger = hostLedgerForEnv(scopedEnv);
+    const probe = await openSquare(squarePath, { hostLedger, env: scopedEnv });
+    const binding = (await projectSessionBindings({
+        hostLedger,
+        sessionId,
+        location: probe.location,
+        scopes: ['user', 'local'],
+    }))[0];
+    await closeOpenSquare(probe);
     if (binding === undefined || !await squareExists(squarePath))
         return;
     const reader = await openSquare(squarePath);
-    const joined = await entryPresentation(reader, binding.name).finally(() => closeOpenSquare(reader));
+    const joined = await entryPresentation(reader, binding.participant).finally(() => closeOpenSquare(reader));
     if (!joined.joined)
         return;
-    const square = await Square.at({ path: squarePath });
+    const square = await Square.at({ path: squarePath, hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv });
     try {
-        const participant = await square.join(binding.name);
+        const participant = await square.join(binding.participant);
         await participant.done();
+        await square.reconcileBinding();
+        const cleanup = await openSquare(squarePath);
+        try {
+            await retireWakeRouteFromArtifact(cleanup.artifact, { location: squarePath, participant: binding.participant, sessionId });
+        }
+        finally {
+            await closeOpenSquare(cleanup);
+        }
     }
     finally {
         await square.close();
     }
-    await recordSessionDone(sessionId, binding.name, squarePath, channel, env);
 }

package/dist/boundary-presentation.d.ts

@@ -2,4 +2,4 @@ import type { InboxMembership } from './model.js';
 /** A fresh blocking catch owns only the notifications admitted by its filter. */
 export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
 export declare function renderPendingAtBoundary(inbox: InboxMembership[]): string;
-export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T | Promise<T>, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;
+export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T | Promise<T>, lookup?: (sessionId: string, env?: NodeJS.ProcessEnv) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;

package/dist/boundary-presentation.js

@@ -1,9 +1,11 @@
 import { leaseOwnsNotification } from './delivery.js';
-import { markBoundarySeen } from './square-wiring.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 { ATTENTION_BODY_MAX, renderAttentionPreview } from './attention-presentation.js';
-import { presentOnce } from './presented.js';
 const CONTEXT_MAX = 1200;
+const presentationLocks = new Map();
 function pendingCount(inbox) {
     return inbox.reduce((total, membership) => total + membership.notifications.length, 0);
 }
@@ -60,9 +62,11 @@ function renderBoundary(inbox) {
             continue;
         }
         blocks.push(block);
-        if (notification.body.replace(/\r\n/g, '\n').length <= ATTENTION_BODY_MAX) {
-            complete.push({ membership, actIndexes: [notification.actIndex] });
-        }
+        complete.push({
+            membership,
+            actIndexes: [notification.actIndex],
+            markSeen: notification.body.replace(/\r\n/g, '\n').length <= ATTENTION_BODY_MAX,
+        });
     }
     return {
         context: [
@@ -77,15 +81,55 @@ function renderBoundary(inbox) {
     };
 }
 export async function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env, signal) {
-    const inbox = await lookup(sessionId);
-    let delivered;
-    const result = await presentOnce(sessionId, () => pendingAtBoundary(inbox), (inbox) => {
-        delivered = renderBoundary(inbox);
-        return present(delivered.context);
-    }, env, Date.now(), signal);
-    if (result !== undefined && delivered !== undefined) {
-        for (const entry of delivered.complete) {
-            await markBoundarySeen(entry.membership.squarePath, entry.membership.name, entry.membership.ownerId, entry.actIndexes);
+    const inbox = await lookup(sessionId, env);
+    if (signal?.aborted)
+        return undefined;
+    const delivered = renderBoundary(pendingAtBoundary(inbox));
+    if (delivered.context === '')
+        return undefined;
+    let result;
+    let rendered = false;
+    const renderOnce = async () => { if (!rendered) {
+        rendered = true;
+        result = await present(delivered.context);
+    } };
+    for (const entry of delivered.complete) {
+        let square;
+        try {
+            try {
+                square = await openSquare(entry.membership.squarePath, { env });
+            }
+            catch {
+                continue;
+            }
+            for (const index of entry.actIndexes) {
+                const key = `${entry.membership.squarePath}\u0000${entry.membership.name.toLocaleLowerCase()}\u0000${index}`;
+                const prior = presentationLocks.get(key);
+                if (prior !== undefined) {
+                    await prior;
+                    continue;
+                }
+                const work = presentPending({ artifact: square.artifact, location: entry.membership.squarePath, participant: entry.membership.name, activity: index, hostLedger: square.hostLedger, session: sessionId, sink: { present: renderOnce }, markSeen: entry.markSeen, now: Date.now() }).then(async (outcome) => {
+                    // A stale projection can outlive its activity; still surface the bounded preview,
+                    // but there is no artifact observation to commit.
+                    if (!outcome.presented) {
+                        const snapshot = await square.artifact.read().catch(() => undefined);
+                        if (snapshot?.state.acts.every((activity) => activity.index !== index))
+                            await renderOnce();
+                    }
+                });
+                presentationLocks.set(key, work);
+                try {
+                    await work;
+                }
+                finally {
+                    presentationLocks.delete(key);
+                }
+            }
+        }
+        finally {
+            if (square !== undefined)
+                await closeOpenSquare(square);
         }
     }
     return result;

package/dist/catch-decisions.d.ts

@@ -0,0 +1,17 @@
+import { type Perception } from './square-core.js';
+import { type SquareState, type StoredAct } from './model.js';
+import type { CatchOptions } from './square-facade.js';
+export interface CatchDecision {
+    readonly viewer: string;
+    readonly delivered: readonly StoredAct[];
+    readonly perceptions: ReadonlyMap<number, Perception>;
+    readonly consumedThrough: string | null;
+    readonly changed: boolean;
+}
+export interface CatchProjection {
+    cursorFor(name: string): number;
+    directedTo(activity: StoredAct, name: string): boolean;
+    perceive(activity: StoredAct, name: string): Perception;
+}
+/** Pure catch selection and acknowledgement over one SquareState snapshot. */
+export declare function decideCatch(state: SquareState, requestedName: string, options: CatchOptions, at: number, project?: (state: SquareState) => CatchProjection): CatchDecision;

package/dist/catch-decisions.js

@@ -0,0 +1,53 @@
+import { audienceOf, formatActivityId, replayLandedAudiences } from './square-core.js';
+import { matchesMentionTarget, readCursor, recordObservation } from './runtime.js';
+import { participantIdentity } from './participant-identity.js';
+import { SquareError, sameName, validateName } from './model.js';
+import { resolveRosterName, rosterNames } from './runtime.js';
+function defaultProjection(state) {
+    const landed = replayLandedAudiences(state.acts);
+    return {
+        cursorFor: (name) => readCursor(state, name, landed),
+        directedTo: (activity, name) => activity.kind === 'say' && landed.includes(activity, name),
+        perceive: (activity, name) => activity.kind !== 'say' || sameName(activity.actor, name) || landed.includes(activity, name) ? 'full' : 'presence',
+    };
+}
+function resolveCatchName(state, requestedName) {
+    validateName(requestedName);
+    const known = resolveRosterName(state, requestedName);
+    if (known === undefined) {
+        throw new SquareError('invalid_args', `Unknown participant "${participantIdentity(requestedName)}". Expected one of: ${rosterNames(state).map(participantIdentity).join(', ')}.`);
+    }
+    return known;
+}
+/** Pure catch selection and acknowledgement over one SquareState snapshot. */
+export function decideCatch(state, requestedName, options, at, project = defaultProjection) {
+    const viewer = resolveCatchName(state, requestedName);
+    const delivery = project(state);
+    const cursor = delivery.cursorFor(viewer);
+    const from = options.from;
+    const mentionOnly = options.mention === true;
+    const delivered = [];
+    const perceptions = new Map();
+    for (const activity of state.acts) {
+        if (activity.index <= cursor || activity.kind !== 'say' || !delivery.directedTo(activity, viewer))
+            continue;
+        if (from !== undefined && !from.some((participant) => sameName(participant, activity.actor)))
+            continue;
+        if (mentionOnly && audienceOf(activity).kind !== 'bell' && !matchesMentionTarget(activity, viewer))
+            continue;
+        delivered.push(activity);
+        perceptions.set(activity.index, delivery.perceive(activity, viewer));
+    }
+    let changed = false;
+    for (const activity of delivered) {
+        changed = recordObservation(state, viewer, activity.index, 'seen', at) || changed;
+    }
+    const consumed = delivery.cursorFor(viewer);
+    return {
+        viewer,
+        delivered,
+        perceptions,
+        consumedThrough: consumed < 0 ? null : formatActivityId(consumed),
+        changed,
+    };
+}

package/dist/claude-hook.d.ts

@@ -1,9 +1,10 @@
 import type { InboxMembership } from './model.js';
+import type { WakeAdapter } from './delivery.js';
 export interface NativeHookInput {
     session_id?: unknown;
     hook_event_name?: unknown;
     cwd?: unknown;
 }
 export declare function runClaudeHookAsync(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
-export declare function claudeHookResponse(input: NativeHookInput, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<object | undefined>;
+export declare function claudeHookResponse(input: NativeHookInput, lookup?: (sessionId: string, env?: NodeJS.ProcessEnv) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv, deliveryAdapters?: WakeAdapter[]): Promise<object | undefined>;
 export declare function runClaudeHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/claude-hook.js

@@ -1,6 +1,7 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
 import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+import { sweepPrivilegedPending } from './notifications.js';
 export async function runClaudeHookAsync(inputText, env = process.env) {
     let input;
     try {
@@ -34,12 +35,14 @@ export async function runClaudeHookAsync(inputText, env = process.env) {
     }
     return runClaudeHook(inputText, env);
 }
-export async function claudeHookResponse(input, lookup = sessionInbox, env = process.env) {
+export async function claudeHookResponse(input, lookup = sessionInbox, env = process.env, deliveryAdapters) {
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (input.hook_event_name !== 'PostToolBatch')
         return undefined;
-    return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolBatch', additionalContext: context } }), lookup, env);
+    const response = await presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolBatch', additionalContext: context } }), lookup, env);
+    await sweepPrivilegedPending(typeof input.cwd === 'string' ? input.cwd : process.cwd(), env, deliveryAdapters).catch(() => undefined);
+    return response;
 }
 export async function runClaudeHook(inputText, env = process.env) {
     let input;

package/dist/cli/context.js

@@ -1,7 +1,8 @@
 import os from 'node:os';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
-import { localParticipantName } from '../registry.js';
+import { createHostLedgerPort } from '../host-ledger-file-adapter.js';
+import { projectSessionBindings, sessionIdsFromEnvironment } from '../square-projections.js';
 export async function readStdin() {
     try {
         let content = '';
@@ -144,7 +145,14 @@ export async function parseGlobalArgs(rawArgs) {
     }
     const squarePath = requestedPath ?? configured;
     if (name === undefined && squarePath !== undefined && command !== undefined && locationIsRequired(command)) {
-        name = await localParticipantName(squarePath);
+        const bindings = (await Promise.all(sessionIdsFromEnvironment().map((sessionId) => projectSessionBindings({
+            hostLedger: createHostLedgerPort(),
+            location: squarePath,
+            sessionId,
+            scopes: ['user', 'local'],
+        })))).flat();
+        const names = new Set(bindings.map((binding) => binding.participant));
+        name = names.size === 1 ? [...names][0] : undefined;
     }
     return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, args };
 }

package/dist/cli/observation-commands.d.ts

@@ -1,5 +1,9 @@
 import { type ActivitiesOptions, type WatchOptions } from '../model.js';
 import { type CommandSpec } from './context.js';
+interface HistoryCommandOptions extends ActivitiesOptions {
+    noTruncate: boolean;
+    continuationArgs: string[];
+}
 export declare const listCommand: CommandSpec<string[]>;
 interface StreamIntent {
     ndjson: boolean;
@@ -7,7 +11,7 @@ interface StreamIntent {
 }
 export declare const streamCommand: CommandSpec<StreamIntent>;
 export declare const catchCommand: CommandSpec<WatchOptions>;
-export declare const historyCommand: CommandSpec<ActivitiesOptions, string>;
+export declare const historyCommand: CommandSpec<HistoryCommandOptions, string>;
 export declare const participantsCommand: CommandSpec<undefined, string>;
 export declare const statusCommand: CommandSpec<undefined, string>;
 interface InboxIntent {