@astrosheep/square 0.3.71 → 0.3.72

package/dist/packages/agent-delivery/src/claude.d.ts

@@ -1,14 +1,5 @@
-import type { ClaudeDeliveryResult, ClaudeSendTextOptions, ClaudeTarget } from './types.js';
-export interface ClaudeConnectExistingOptions {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
+import type { ClaudeConnectOptions, ClaudeDeliveryResult, ClaudeSendTextOptions, ClaudeTarget } from './types.js';
 /** Resolve an explicitly identified existing Claude native inbox; never discovers or starts one. */
-export declare function connectExisting(options: ClaudeConnectExistingOptions): Promise<ClaudeTarget>;
+export declare function connectExisting(options: ClaudeConnectOptions): Promise<ClaudeTarget>;
 /** Write once to Claude's next native boundary; local write is never native admission. */
 export declare function sendText(target: ClaudeTarget, text: string, options?: ClaudeSendTextOptions): Promise<ClaudeDeliveryResult>;

package/dist/packages/agent-delivery/src/index.d.ts

@@ -1,4 +1,6 @@
 import { DeliveryError } from './errors.js';
+import type { OpenCodeConnectOptions, ClaudeConnectOptions, PiConnectOptions, PaseoConnectOptions } from './types.js';
+export type { OpenCodeConnectOptions, ClaudeConnectOptions, PiConnectOptions, PaseoConnectOptions } from './types.js';
 export interface SendOptions {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
@@ -16,48 +18,6 @@ export interface Steerable<O = SendOptions> {
 export interface Queueable<O = SendOptions> {
     queue(text: string, options?: O): Promise<Receipt>;
 }
-export interface OpenCodeConnectOptions {
-    readonly harness: 'opencode';
-    readonly sessionId: string;
-    readonly endpoint?: {
-        readonly url: string;
-        readonly auth?: {
-            readonly type: 'basic';
-            readonly username: string;
-            readonly password: string;
-        };
-    };
-    readonly registrationFile?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export interface ClaudeConnectOptions {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export interface PiConnectOptions {
-    readonly harness: 'pi';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export interface PaseoConnectOptions {
-    readonly harness: 'paseo';
-    readonly agentId: string;
-    readonly endpoint?: string;
-    readonly password?: string;
-    readonly authHeader?: string;
-    readonly localCredential?: string;
-    readonly paseoHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
 export type OpenCodeAgent = Steerable<KeyedSendOptions> & Queueable<KeyedSendOptions> & {
     readonly harness: 'opencode';
     readonly sessionId: string;

package/dist/packages/agent-delivery/src/opencode.d.ts

@@ -1,14 +1,5 @@
-import { type Endpoint } from '@opencode/client/service';
-import type { OpenCodeDeliveryResult, OpenCodeTarget, OpenCodeSendTextOptions } from './types.js';
-export interface OpenCodeConnectExistingOptions {
-    readonly harness: 'opencode';
-    readonly sessionId: string;
-    readonly endpoint?: Endpoint;
-    readonly registrationFile?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
+import type { OpenCodeConnectOptions, OpenCodeDeliveryResult, OpenCodeTarget, OpenCodeSendTextOptions } from './types.js';
 /** Resolve an existing service and persisted session. Never starts or stops a service. */
-export declare function connectExisting(options: OpenCodeConnectExistingOptions): Promise<OpenCodeTarget>;
+export declare function connectExisting(options: OpenCodeConnectOptions): Promise<OpenCodeTarget>;
 /** Submit once through the shared native sender; HTTP metadata alone refines rejection. */
 export declare function sendText(target: OpenCodeTarget, text: string, options?: OpenCodeSendTextOptions): Promise<OpenCodeDeliveryResult>;

package/dist/packages/agent-delivery/src/paseo.d.ts

@@ -1,17 +1,6 @@
-import type { PaseoDeliveryResult, PaseoSendTextOptions, PaseoTarget } from './types.js';
-export interface PaseoConnectExistingOptions {
-    readonly harness: 'paseo';
-    readonly agentId: string;
-    readonly endpoint?: string;
-    readonly password?: string;
-    readonly authHeader?: string;
-    readonly localCredential?: string;
-    readonly paseoHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
+import type { PaseoConnectOptions, PaseoDeliveryResult, PaseoSendTextOptions, PaseoTarget } from './types.js';
 /** Connect to an existing daemon and address one existing agent. Never starts or stops anything. */
-export declare function connectPaseo(options: PaseoConnectExistingOptions): Promise<PaseoTarget>;
+export declare function connectPaseo(options: PaseoConnectOptions): Promise<PaseoTarget>;
 /**
  * Every call owns its daemon connection: one for connect to prove the endpoint
  * and credential, and one per send, closed again as soon as the daemon answers.

package/dist/packages/agent-delivery/src/pi-client.d.ts

@@ -1,10 +1,3 @@
-import type { PiDeliveryResult, PiSendTextOptions, PiTarget } from './types.js';
-export interface PiConnectExistingOptions {
-    readonly harness: 'pi';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
-export declare function connectPi(options: PiConnectExistingOptions): Promise<PiTarget>;
+import type { PiConnectOptions, PiDeliveryResult, PiSendTextOptions, PiTarget } from './types.js';
+export declare function connectPi(options: PiConnectOptions): Promise<PiTarget>;
 export declare function sendPiText(target: PiTarget, text: string, options?: PiSendTextOptions): Promise<PiDeliveryResult>;

package/dist/packages/agent-delivery/src/types.d.ts

@@ -46,6 +46,48 @@ export interface PaseoSendTextOptions {
     readonly signal?: AbortSignal;
 }
 export type SendTextOptions = OpenCodeSendTextOptions | ClaudeSendTextOptions | PiSendTextOptions | PaseoSendTextOptions;
+export interface OpenCodeConnectOptions {
+    readonly harness: 'opencode';
+    readonly sessionId: string;
+    readonly endpoint?: {
+        readonly url: string;
+        readonly auth?: {
+            readonly type: 'basic';
+            readonly username: string;
+            readonly password: string;
+        };
+    };
+    readonly registrationFile?: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface ClaudeConnectOptions {
+    readonly harness: 'claude';
+    readonly sessionId: string;
+    readonly endpoint: string;
+    readonly token?: string;
+    readonly claudeHome?: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface PiConnectOptions {
+    readonly harness: 'pi';
+    readonly sessionId: string;
+    readonly endpoint: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface PaseoConnectOptions {
+    readonly harness: 'paseo';
+    readonly agentId: string;
+    readonly endpoint?: string;
+    readonly password?: string;
+    readonly authHeader?: string;
+    readonly localCredential?: string;
+    readonly paseoHome?: string;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
 interface OpenCodeAttempt {
     readonly harness: 'opencode';
     readonly sessionId: string;

package/dist/participant-host.d.ts

@@ -12,8 +12,11 @@ export declare function processIdentity(env: NodeJS.ProcessEnv): {
     channel: PresenceChannel;
 };
 export declare function identityRouteDraft(context: HostContext, participant: string): Promise<Omit<WakeRoute, 'updatedAt'> | undefined>;
-export declare function publishIdentityRoute(context: HostContext, participant: string, epoch?: number): Promise<void>;
+/** One postcommit host observation; presence and route publication fail independently. */
+export declare function publishCommittedIdentity(context: HostContext, participant: string, epoch?: number): Promise<void>;
 export declare function retireIdentityRoute(context: HostContext, participant: string, expectedEpoch?: number): Promise<void>;
 export declare function assertLiveOwner(context: HostContext, participant: string, expectedEpoch?: number): Promise<boolean>;
-/** Presence is best effort and runs only after the artifact mutation commits. */
-export declare function ensureLocalPresence(context: HostContext, participant: string, epoch?: number): Promise<void>;
+/** Best-effort postcommit presence; a returned epoch also witnesses a readable host observation. */
+export declare function ensureLocalPresence(context: HostContext, participant: string, epoch?: number): Promise<{
+    readonly epoch?: number;
+} | undefined>;

package/dist/participant-host.js

@@ -1,5 +1,6 @@
-import { presenceEpoch, readParticipantOwner, sessionOwnsParticipant } from './registry.js';
+import { currentOwner, presenceEpoch, sessionOwnsParticipant } from './registry.js';
 import { firstHarnessSession } from './participant-identity.js';
+import { canonicalPath } from './canonical-path.js';
 import { defaultWakeRouteCapabilities, publishWakeRoute, retireWakeRouteFromArtifact, resolvePrimaryWakeRoute, ROUTE_FRESH_MS } from './routes.js';
 export function processIdentity(env) {
     const found = firstHarnessSession(env);
@@ -13,19 +14,17 @@ export async function identityRouteDraft(context, participant) {
     const capabilities = context.hostLedger === undefined ? { canUse: () => false } : await defaultWakeRouteCapabilities(context.hostLedger);
     return resolvePrimaryWakeRoute({ location: context.location, participant, sessionId: identity.session, provider }, context.env ?? process.env, capabilities);
 }
-async function currentOwnerEpoch(context, participant) {
-    const hostLedger = context.hostLedger;
-    if (hostLedger === undefined || context.location === undefined || context.location === 'memory')
-        return undefined;
-    const owner = await readParticipantOwner(context.location, participant, hostLedger);
-    return owner === undefined ? undefined : presenceEpoch(owner);
-}
-export async function publishIdentityRoute(context, participant, epoch) {
-    const route = await identityRouteDraft(context, participant);
-    if (route === undefined)
+/** One postcommit host observation; presence and route publication fail independently. */
+export async function publishCommittedIdentity(context, participant, epoch) {
+    const observed = await ensureLocalPresence(context, participant, epoch).catch(() => undefined);
+    if (observed === undefined)
         return;
-    const ownerEpoch = epoch ?? await currentOwnerEpoch(context, participant);
-    await publishWakeRoute(context.artifact, { ...route, ...(ownerEpoch === undefined ? {} : { epoch: ownerEpoch }) }, { at: context.clock(), requireCurrentSession: true }).catch(() => undefined);
+    try {
+        const route = await identityRouteDraft(context, participant);
+        if (route !== undefined)
+            await publishWakeRoute(context.artifact, { ...route, ...observed }, { at: context.clock(), requireCurrentSession: true });
+    }
+    catch { /* Optional route enrichment cannot undo the committed activity. */ }
 }
 export async function retireIdentityRoute(context, participant, expectedEpoch) {
     if (context.location === undefined || context.location === 'memory')
@@ -43,35 +42,42 @@ export async function assertLiveOwner(context, participant, expectedEpoch) {
         return true;
     return sessionOwnsParticipant(context.location, participant, identity.session, hostLedger, expectedEpoch);
 }
-/** Presence is best effort and runs only after the artifact mutation commits. */
+/** Best-effort postcommit presence; a returned epoch also witnesses a readable host observation. */
 export async function ensureLocalPresence(context, participant, epoch) {
     if (context.hostLedger === undefined || context.location === undefined || context.location === 'memory')
         return;
     const identity = processIdentity(context.env ?? process.env);
-    const ownerEpoch = epoch ?? await currentOwnerEpoch(context, participant);
-    const now = context.clock();
-    // Semantic publish: an unexpired presence row already stands when it carries the same owner epoch.
+    const now = Date.now();
+    let existing;
     try {
-        const existing = await context.hostLedger.listPresence({ location: context.location, participant, session: identity.session, now });
-        if (existing.some((row) => row.channel === identity.channel
-            && now - (row.updatedAt ?? 0) < ROUTE_FRESH_MS
-            && (ownerEpoch === undefined || presenceEpoch(row) === ownerEpoch)))
-            return;
+        existing = await context.hostLedger.listPresence({ location: await canonicalPath(context.location), participant, now });
+    }
+    catch (error) {
+        process.stderr.write(`! host presence degraded: ${error instanceof Error ? error.message : String(error)}\n`);
+        return;
+    }
+    const owner = currentOwner(existing);
+    const ownerEpoch = epoch ?? (owner === undefined ? undefined : presenceEpoch(owner));
+    const observed = ownerEpoch === undefined ? {} : { epoch: ownerEpoch };
+    // A fresh exact local binding at the observed (or explicit claim) generation already stands.
+    if (existing.some((row) => row.session === identity.session && row.channel === identity.channel
+        && now - (row.updatedAt ?? 0) < ROUTE_FRESH_MS
+        && (ownerEpoch === undefined || presenceEpoch(row) === ownerEpoch)))
+        return observed;
+    try {
+        const result = await context.hostLedger.ensurePresence({
+            location: context.location,
+            participant,
+            session: identity.session,
+            channel: identity.channel,
+            updatedAt: Date.now(),
+            ...(ownerEpoch === undefined || ownerEpoch <= 0 ? {} : { epoch: ownerEpoch }),
+        });
+        if (result.status === 'degraded')
+            throw result.error;
+    }
+    catch (error) {
+        process.stderr.write(`! host presence degraded: ${error instanceof Error ? error.message : String(error)}\n`);
     }
-    catch { /* fall through to the best-effort ensure below */ }
-    const result = await context.hostLedger.ensurePresence({
-        location: context.location,
-        participant,
-        session: identity.session,
-        channel: identity.channel,
-        // Presence rows are host-ledger wall-time evidence; the square clock belongs to artifact activities.
-        updatedAt: Date.now(),
-        ...(ownerEpoch === undefined || ownerEpoch <= 0 ? {} : { epoch: ownerEpoch }),
-    }).catch((error) => ({
-        status: 'degraded',
-        record: { location: context.location, participant, session: identity.session, channel: identity.channel },
-        error,
-    }));
-    if (result.status === 'degraded')
-        process.stderr.write(`! host presence degraded: ${result.error instanceof Error ? result.error.message : String(result.error)}\n`);
+    return observed;
 }

package/dist/registry.d.ts

@@ -2,6 +2,8 @@
 import { type FileHostLedgerPort } from './host-ledger-file-adapter.js';
 import type { HostLedgerPort, PresenceChannel, PresenceRecord } from './host-ledger.js';
 export declare function presenceEpoch(record: PresenceRecord | undefined): number;
+/** The current owner: the highest epoch wins, then the most recently updated row. */
+export declare function currentOwner(rows: readonly PresenceRecord[]): PresenceRecord | undefined;
 export declare function localParticipantName(squarePath: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
 export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
 export type OwnershipClaim = {

package/dist/registry.js

@@ -8,7 +8,7 @@ export function presenceEpoch(record) {
     return typeof record?.epoch === 'number' && Number.isSafeInteger(record.epoch) && record.epoch > 0 ? record.epoch : 0;
 }
 /** The current owner: the highest epoch wins, then the most recently updated row. */
-function currentOwner(rows) {
+export function currentOwner(rows) {
     return [...rows].sort((left, right) => presenceEpoch(right) - presenceEpoch(left) || (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
 }
 export async function localParticipantName(squarePath, hostLedger, env = process.env) { const canonical = await canonicalPath(squarePath); const names = new Set((await Promise.all(localSessionIdentities(env).map(async (identity) => (await hostLedger.listPresence({ location: canonical, session: identity.sessionId })).map((row) => row.participant)))).flat()); return names.size === 1 ? [...names][0] : undefined; }

package/dist/routes.js

@@ -3,15 +3,6 @@ import { canonicalPath, canonicalPathSync } from './canonical-path.js';
 export { WAKE_ROUTE_KINDS } from './model.js';
 export const ROUTE_FRESH_MS = 24 * 60 * 60 * 1000;
 export async function defaultWakeRouteCapabilities(hostLedger) {
-    let userCapable = hostLedger !== undefined;
-    if (hostLedger !== undefined) {
-        try {
-            await hostLedger.listPresence({ now: Date.now() });
-        }
-        catch {
-            userCapable = false;
-        }
-    }
     const available = new Set();
     try {
         const { CodexQueueAdapter } = await import('./codex-queue.js');
@@ -23,7 +14,7 @@ export async function defaultWakeRouteCapabilities(hostLedger) {
         available.add(new PaseoAdapter().kind);
     }
     catch { /* optional */ }
-    return { canUse: (kind, address) => userCapable && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
+    return { canUse: (kind, address) => hostLedger !== undefined && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
 }
 export function resolvePrimaryWakeRoute(boundary, env, capabilities) {
     const paseoAgentId = env.PASEO_AGENT_ID?.trim();

package/dist/square-actions.js

@@ -5,14 +5,9 @@ import { deliverPending } from './delivery-operations.js';
 import { decideCatch } from './catch-decisions.js';
 import { inSquareCount } from './runtime.js';
 import { claimSessionParticipant, claimSessionTakeover, presenceEpoch, releaseSessionParticipantClaim, readParticipantOwner } from './registry.js';
-import { assertLiveOwner, ensureLocalPresence, identityRouteDraft, processIdentity, publishIdentityRoute, retireIdentityRoute } from './participant-host.js';
+import { assertLiveOwner, ensureLocalPresence, identityRouteDraft, processIdentity, publishCommittedIdentity, retireIdentityRoute } from './participant-host.js';
 import { applyWakeRoute, dropEndedSessionWakeRoutes, dropParticipantWakeRoutes, dropSessionWakeRoutes, sessionCanEndParticipant } from './routes.js';
 import { parseRequiredActivityId, toPublicActivity } from './views.js';
-/** Host enrichment is best effort after an authoritative artifact commit. */
-async function publishCommittedPresence(square, name, epoch) {
-    await ensureLocalPresence(square, name, epoch).catch(() => undefined);
-    await publishIdentityRoute(square, name, epoch).catch(() => undefined);
-}
 function throwIfAborted(control) { if (control?.signal?.aborted)
     throw control.signal.reason ?? new Error('Operation aborted'); }
 export async function catchUp(square, name, options = {}, control, leaseId) {
@@ -27,7 +22,7 @@ export async function catchUp(square, name, options = {}, control, leaseId) {
         return decideCatch(facts, name, options, square.clock());
     }, control?.signal)).value;
     if (selected !== null)
-        await publishCommittedPresence(square, selected.participant);
+        await publishCommittedIdentity(square, selected.participant);
     return selected;
 }
 export async function join(square, name, control) {
@@ -80,7 +75,7 @@ export async function join(square, name, control) {
             await releaseSessionParticipantClaim(hostLedger, ownershipClaim).catch(() => undefined);
         throw error;
     }
-    await publishCommittedPresence(square, committed.name, epoch);
+    await publishCommittedIdentity(square, committed.name, epoch);
     return {
         name: committed.name, activity: committed.stored === null ? null : toPublicActivity(committed.stored),
         participantCount: committed.participantCount, reconnected: false,
@@ -118,7 +113,7 @@ export async function takeover(square, name, _oldSessionIds = [], control) {
         }, async (claim) => {
             throwIfAborted(control);
             const committed = await commitLifecycle();
-            await publishCommittedPresence(square, committed.name, claim.epoch);
+            await publishCommittedIdentity(square, committed.name, claim.epoch);
             return committed;
         }, control?.signal);
         if (outcome.status === 'busy')
@@ -126,7 +121,7 @@ export async function takeover(square, name, _oldSessionIds = [], control) {
         return { name: outcome.result.name, activities: outcome.result.stored.map(toPublicActivity), participantCount: outcome.result.participantCount, epoch: outcome.epoch };
     }
     const committed = await commitLifecycle();
-    await publishCommittedPresence(square, committed.name);
+    await publishCommittedIdentity(square, committed.name);
     return { name: committed.name, activities: committed.stored.map(toPublicActivity), participantCount: committed.participantCount };
 }
 export async function implicitJoin(square, name, control) {
@@ -147,11 +142,12 @@ export async function implicitJoin(square, name, control) {
         }
         return { name: decision.joinedName, state: decision.state, stored: decision.joinAct === undefined ? null : facts.land(decision.joinAct) };
     }, control?.signal)).value;
-    await ensureLocalPresence(square, committed.name);
+    if (committed.stored !== null)
+        await publishCommittedIdentity(square, committed.name);
+    else
+        await ensureLocalPresence(square, committed.name);
     if (committed.state === 'done')
         await retireIdentityRoute(square, committed.name);
-    else if (committed.stored !== null)
-        await publishIdentityRoute(square, committed.name);
     return { name: committed.name, state: committed.state, activity: committed.stored === null ? null : toPublicActivity(committed.stored) };
 }
 function rejectUnsentActivity(operation) {
@@ -210,7 +206,7 @@ export async function express(square, name, body, options = {}, control) {
             ...(decision.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: decision.replyAuthorNotHere }),
         };
     }, control?.signal)).value;
-    await publishCommittedPresence(square, name);
+    await publishCommittedIdentity(square, name);
     const delivery = square.wakeTransport !== undefined && square.hostLedger !== undefined && square.location !== undefined && square.location !== 'memory'
         ? await deliverPending({ artifact: square.artifact, hostLedger: square.hostLedger, transport: square.wakeTransport, location: square.location, activity: committed.stored.index, now })
             .catch(() => ({ attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 1 }))

package/dist/square-application.js

@@ -13,8 +13,7 @@ import { recoveryObservation, currentParticipant, entryPresentation, eventPresen
 import { hasAutomaticDeliveryIdentity, hostLedgerForEnv, localParticipantName, localSessionIdentities, presenceEpoch, readParticipantOwner } from './registry.js';
 import { projectSessionBindings } from './square-projections.js';
 import { sessionIdsFromEnvironment } from './participant-identity.js';
-import { createDefaultWakeTransport, wakeGraceMs } from './notifications.js';
-import { sweepPending } from './delivery-operations.js';
+import { createDefaultWakeTransport } from './notifications.js';
 import { acquireWatchLease, ownsWatchLease, pulseWatchLease, releaseWatchLease } from './wakes.js';
 import { createSquare, diagnoseSquareFile } from './artifact.js';
 import { migrateSquareFile } from './square-migration.js';
@@ -187,7 +186,7 @@ function caughtResult({ selection, stop }) {
         consumedThrough: selection.consumedThrough, remaining: selection.remaining, idleExpired: stop === 'stale',
     };
 }
-/** Leases, quiet waiting, selection and sweep form one lifecycle for both APIs. */
+/** Leases, quiet waiting and selection form one lifecycle for both APIs. */
 async function catchOwned(square, requested, options = {}, control) {
     let name = requested, subject = 'caller';
     let leaseId;
@@ -204,17 +203,6 @@ async function catchOwned(square, requested, options = {}, control) {
             await releaseWatchLease(square, name, leaseId).catch(() => undefined);
             leaseId = undefined;
         }
-        if (!control?.signal?.aborted && stop !== 'replaced' && stop !== 'already-active'
-            && (waitStarted || selected.activities.length > 0) && square.location !== 'memory'
-            && square.hostLedger !== undefined && square.env?.SQUARE_DISABLE_PASEO_WAKE !== '1') {
-            try {
-                await sweepPending({
-                    artifact: square.artifact, hostLedger: square.hostLedger, location: square.location,
-                    now: square.clock(), graceMs: wakeGraceMs(square.env), limit: 8,
-                });
-            }
-            catch { /* a completed receipt is not conditional on notification enrichment */ }
-        }
         return { selection: selected, stop: terminal, waitStarted, replaced };
     }
     const empty = (stop) => complete(undefined, stop);

package/guides/postcommit-simplification-performance.md

@@ -0,0 +1,36 @@
+# Postcommit simplification: 300-process comparison
+
+Measured on the same local host with Node v26.10.0. Baseline runtime: release 0.3.71 (`90478f8`). Candidate runtime: `03237aa`. The benchmark entrypoint repair in `2bfb68e` was used for both; it replaces imports of removed modules with current artifact/open-square exports, without changing the scenario or deadlines.
+
+```sh
+npm run build
+node --import ./test/sandbox-env.js scripts/benchmark-idle-wait.mjs --workers 300 --mode session --active --no-hints
+```
+
+The command exercises both 1,800 and 18,000 unrelated historical activities. Each of 300 processes observes one bell, recognizes its participant, performs one consuming catch and one empty repeat. These are synthetic Pi bindings without callable native routes. Counts below aggregate all 300 processes; catch latency describes that entire per-process catch phase, not one standalone API call. MB means decimal bytes. Ledger bytes measure instrumented file reads/writes, not physical disk traffic.
+
+| Measurement | Baseline, 1,800 | Candidate, 1,800 | Baseline, 18,000 | Candidate, 18,000 |
+| --- | ---: | ---: | ---: | ---: |
+| Ready / complete | 300 / 300 | 300 / 300 | 300 / 300 | 300 / 300 |
+| Caught per process | 1 | 1 | 1 | 1 |
+| Reconsumed total | 0 | 0 | 0 | 0 |
+| Catch ledger MB | 229.248 | 95.520 | 229.248 | 95.520 |
+| Catch ledger operations | 4,200 | 1,500 | 4,200 | 1,500 |
+| Catch p50 seconds | 18.65 | 5.80 | 22.76 | 5.36 |
+| Catch p95 seconds | 22.57 | 7.11 | 26.62 | 6.85 |
+| Catch SQLite busy errors/retries | 174,082 | 45,555 | 221,701 | 45,028 |
+| Catch CPU seconds, aggregate | 65.01 | 23.31 | 73.50 | 21.65 |
+| Discovery p95 seconds | 1.870 | 1.877 | 1.877 | 1.897 |
+| Five-second idle CPU seconds, aggregate | 3.181 | 3.241 | 3.594 | 3.088 |
+
+These historical SQL/busy counts combined artifact SQL with host-ledger file-lock SQL; “busy errors/retries” counted thrown busy errors, not independently observed retries. They cannot be compared directly with the origin-separated counters now in the benchmark. Rerun both runtimes with the same new script. Its `ledgerSql` reports host-root SQL (including lock databases), separately from artifact SQL. Returned SQL string/blob bytes are not physical I/O or full JSON decode measurements; SQLite's zero instrumented filesystem bytes is a transport change, not a performance gain.
+
+Idle body hydration and ledger bytes remained zero. Each discovery and catch phase hydrated 300 activity bodies. The original 20-second discovery deadline and derived phase guard were unchanged.
+
+The candidate removes a discarded catch-completion sweep and combines postcommit identity publication around one fresh presence observation. Admission remains a separate ownership check. Source changes also consolidate duplicate native connection-option declarations; those type changes do not account for the performance result. Production TypeScript across the three changes is net -57 lines without formatting compression. The benchmark repair is separately net -1 tooling line.
+
+Ledger bytes fell 58.3%, and ledger operation count fell 64.3%. The observed latency improvement is a single before/after local comparison, not an SLA or an isolated causal attribution: other agent work and verification occurred during the broader run, and host load was not controlled. The deterministic operation reduction supports the intended deletion of duplicate work. Idle discovery was not redesigned, and this does not measure callable-route publication or long-lived leased catch optimization.
+
+Each change passed independent review and its declared verification before integration. Root CLI process checks passed all 48 cases; the native adapter package passed 42 cases with its existing Windows-only skip. Full root verification retained its existing skipped case.
+
+Local raw reports: `/tmp/square-round2-baseline-300.json` and `/tmp/square-round2-final-300.json`. These temporary reports are diagnostic artifacts, not repository dependencies. No ledger storage migration or evidence GC change is included.

package/package.json

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

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

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.71",
+  "version": "0.3.72",
   "description": "Native Claude Code inbox delivery for Square participants",
   "types": "./types.d.ts",
   "author": {

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

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

package/plugins/paseo/client/square-message.tsx

@@ -16,14 +16,15 @@ export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<S
   const [expanded, setExpanded] = useState(false);
   const toast = useToast();
   const { text, items } = item.data;
-  const first = items?.[0];
+  const latest = items?.[items.length - 1];
+  const preview = latest?.preview?.replace(/\s+/g, " ").trim();
   const muted = theme.colors.foregroundMuted;
   const foreground = theme.colors.foreground;
-  const padding = layout.compact ? 10 : 14;
   const styles = useMemo(() => ({
     marker: { color: theme.colors.accent, fontSize: 10, marginTop: 2 },
     headline: { color: foreground, fontSize: 13, lineHeight: 19, flexShrink: 1 },
     meta: { color: muted, fontSize: 11, lineHeight: 16, flexShrink: 1 },
+    preview: { color: foreground, fontSize: 12, lineHeight: 18, flexShrink: 1 },
     bodyPanel: {
       backgroundColor: theme.colors.surface1,
       borderRadius: 12,
@@ -45,33 +46,27 @@ export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<S
     <View>
       <Pressable
         accessibilityRole="button"
-        accessibilityLabel={first !== undefined ? squareHeadline(first) : "Square context"}
+        accessibilityLabel={latest !== undefined ? squareHeadline(latest) : "Square context"}
         aria-expanded={expanded}
         onPress={() => setExpanded(value => !value)}
-        style={({ pressed }) => ({
-          flexDirection: "row",
-          alignItems: "flex-start",
-          gap: 7,
-          paddingVertical: 2,
-          opacity: pressed ? 0.6 : 1,
-        })}
+        style={({ pressed }) => ({ opacity: pressed ? 0.6 : 1 })}
       >
-        <Text style={styles.marker}>■</Text>
-        <View style={{
-          flex: 1,
-          minWidth: 0,
-          flexDirection: layout.compact ? "column" : "row",
-          alignItems: layout.compact ? "flex-start" : "center",
-          gap: layout.compact ? 2 : 8,
-        }}>
-          <Text numberOfLines={layout.compact ? 2 : 1} style={styles.headline}>
-            {first !== undefined ? squareHeadline(first) : "Square context"}
+        <View style={{ flexDirection: "row", alignItems: "flex-start", gap: 7, paddingVertical: 2 }}>
+          <Text style={styles.marker}>■</Text>
+          <Text numberOfLines={1} style={styles.headline}>
+            {latest?.square ?? "Square context"}
           </Text>
-          {first && <Text numberOfLines={1} style={styles.meta}>
-            {first.square}{items && items.length > 1 ? ` · +${items.length - 1} more` : ""}
-          </Text>}
+          {items && items.length > 1 && <Text style={styles.meta}>· {items.length} landed</Text>}
+          <View style={{ flex: 1 }} />
+          <View style={{ marginTop: 3 }}><Icon name={expanded ? "ChevronDown" : "ChevronRight"} size={14} color={muted} /></View>
         </View>
-        <View style={{ marginTop: 3 }}><Icon name={expanded ? "ChevronDown" : "ChevronRight"} size={14} color={muted} /></View>
+        {(latest?.actor !== undefined || preview) && <View style={{ marginLeft: 17, marginTop: 2 }}>
+          <Text numberOfLines={1} style={styles.preview}>
+            <Text style={{ color: theme.colors.accent, fontSize: 10 }}>● </Text>
+            {latest?.actor !== undefined && <Text style={styles.meta}>{latest.actor} </Text>}
+            {preview}
+          </Text>
+        </View>}
       </Pressable>
       {expanded && <View style={styles.bodyPanel}>
         <Text selectable style={styles.bodyText}>{text}</Text>

package/plugins/paseo/shared/message.ts

@@ -6,6 +6,7 @@ export const squareCardDetailsSchema = z.object({
     actor: z.string().optional(),
     recipient: z.string().optional(),
     route: z.enum(["mention", "reply", "attention", "bell"]).optional(),
+    preview: z.string().optional(),
     description: z.string(),
   })).min(1),
 });

package/plugins/pi/square-pi.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { presentPendingAtBoundary, renderPendingAtBoundary } from '../../dist/boundary-presentation.js';
 import { automaticSessionEnd, automaticSessionStart } from '../../dist/automatic-session.js';
 import { sessionInbox, observeSessionPending } from '../../dist/inbox.js';
-import { renderAttentionDescription } from '../../dist/attention-presentation.js';
+import { previewAttentionBody, renderAttentionDescription } from '../../dist/attention-presentation.js';
 import { createPiReceiver, sendPiMessage } from '../../dist/packages/agent-delivery/src/pi.js';
 
 class PiDeliveryDroppedError extends Error {
@@ -38,6 +38,7 @@ export function pendingCardDetails(pending) {
     actor: note.actor,
     recipient: membership.name,
     route: note.route,
+    preview: previewAttentionBody(note.body),
     description: renderAttentionDescription({ actor: note.actor, recipient: membership.name, route: note.route }),
   })));
   return items.length === 0 ? undefined : { items };