@astrosheep/square 0.3.29 → 0.3.31

package/dist/wake-attempts.js

@@ -1,112 +1,48 @@
-import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { withFileLock } from './file-lock.js';
 import { isWakeRouteKind, nameKey } from './model.js';
 import { canonicalSquarePath } from './registry.js';
 import { formatActivityId, parseActivityId } from './square-core.js';
-const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-const LOCK_STALE_MS = 5 * 60 * 1000;
-const LOCK_RETRY_MS = 10;
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
+import { terminalWakeEvidence } from './square-projections.js';
+export { hasAttemptableWakeRoute, isWakeRouteAttemptable, terminalWakeEvidence } from './square-projections.js';
 const VALID_OUTCOMES = new Set(['accepted', 'unknown', 'failed']);
+function ledger(env) {
+    return createHostLedgerPort({ userPath: env.SQUARE_HOST_LEDGER_USER ?? path.dirname(wakeAttemptsPath(env)), readableScopes: ['user'], writableScope: 'user' });
+}
 export function wakeAttemptsPath(env = process.env) {
     return env.SQUARE_WAKE_ATTEMPTS || path.join(os.homedir(), '.square', 'wake-attempts.ndjsonl');
 }
 export async function wakeAttentionKey(attention) {
     return JSON.stringify([await canonicalSquarePath(attention.squarePath), formatActivityId(attention.actIndex), nameKey(attention.recipient)]);
 }
-function parseRow(raw, now) {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-    if (value === null || typeof value !== 'object')
-        return undefined;
-    const row = value;
-    if (row.v !== 1 || typeof row.ts !== 'number' || !Number.isFinite(row.ts) || row.ts > now || now - row.ts > RETENTION_MS ||
-        row.attention === undefined || typeof row.attention.square_path !== 'string' || row.attention.square_path === '' ||
-        typeof row.attention.act_id !== 'string' || parseActivityId(row.attention.act_id) === undefined ||
-        typeof row.attention.recipient !== 'string' || row.attention.recipient === '' ||
-        typeof row.outcome !== 'string' || !VALID_OUTCOMES.has(row.outcome) ||
-        typeof row.attempt_n !== 'number' || !Number.isInteger(row.attempt_n) || row.attempt_n <= 0 ||
-        !isWakeRouteKind(row.route_kind) ||
-        (row.signature !== undefined && typeof row.signature !== 'string') ||
-        (row.outcome !== 'accepted' && (typeof row.signature !== 'string' || row.signature === '')) ||
-        (row.message !== undefined && typeof row.message !== 'string'))
-        return undefined;
-    return row;
+export async function claimWakeDispatch(attention, leaseId, leaseMs, env = process.env, at = Date.now(), session) {
+    return ledger(env).claimWakeDispatch({ attention, leaseId, leaseMs, at, session });
 }
-async function readRowsFromFile(filePath, now) {
-    let raw;
-    try {
-        raw = await fs.promises.readFile(filePath, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    return raw.split('\n').filter(Boolean).map((line) => parseRow(line, now)).filter((row) => row !== undefined);
+export async function transitionWakeDispatch(attention, leaseId, phase, leaseMs, routeKind, attemptN, session, env = process.env, at = Date.now()) {
+    return ledger(env).transitionWakeDispatch({ attention, leaseId, phase, leaseMs, routeKind, attemptN, session, at });
 }
-async function readRows(env, now) {
-    return readRowsFromFile(wakeAttemptsPath(env), now);
+export async function releaseWakeDispatch(attention, leaseId, env = process.env, at = Date.now()) {
+    await ledger(env).releaseWakeDispatch({ attention, leaseId, at });
 }
-async function writeRows(filePath, rows) {
-    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    await fs.promises.writeFile(temporary, rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : ''), {
-        mode: 0o600,
+async function readRows(env, now) {
+    const records = await ledger(env).listWakeAttempts({ now });
+    return records.flatMap((record) => {
+        const actIndex = parseActivityId(record.activity);
+        if (actIndex === undefined || !isWakeRouteKind(record.routeKind) || !VALID_OUTCOMES.has(record.outcome) || typeof record.attemptN !== 'number')
+            return [];
+        return [{ at: record.at ?? now, attention: { squarePath: record.location, actIndex, recipient: record.participant }, routeKind: record.routeKind, outcome: record.outcome, attemptN: record.attemptN, ...(record.signature === undefined ? {} : { signature: record.signature }), ...(record.session === undefined ? {} : { session: record.session }), ...(record.message === undefined ? {} : { message: record.message }), ...(record.diagnostic === undefined ? {} : { diagnostic: record.diagnostic }) }];
     });
-    await fs.promises.rename(temporary, filePath);
-}
-async function fromRow(row) {
-    const actIndex = parseActivityId(row.attention.act_id);
-    if (actIndex === undefined)
-        throw new Error(`Invalid wake activity id: ${row.attention.act_id}`);
-    return {
-        at: row.ts,
-        attention: {
-            squarePath: await canonicalSquarePath(row.attention.square_path),
-            actIndex,
-            recipient: row.attention.recipient,
-        },
-        routeKind: row.route_kind,
-        outcome: row.outcome,
-        ...(row.signature === undefined ? {} : { signature: row.signature }),
-        attemptN: row.attempt_n,
-        ...(row.message === undefined ? {} : { message: row.message }),
-        ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
-    };
 }
 export async function readWakeAttempts(opts = {}) {
     const now = opts.now ?? Date.now();
     const expected = opts.attention === undefined ? undefined : await wakeAttentionKey(opts.attention);
-    const attempts = await Promise.all((await readRows(opts.env ?? process.env, now)).map(fromRow));
+    const attempts = await readRows(opts.env ?? process.env, now);
+    const scoped = opts.sessionId === undefined ? attempts : attempts.filter((attempt) => attempt.session === opts.sessionId);
     if (expected === undefined)
-        return attempts;
-    const keys = await Promise.all(attempts.map((attempt) => wakeAttentionKey(attempt.attention)));
-    return attempts.filter((_, index) => keys[index] === expected);
-}
-export function terminalWakeEvidence(attempts) {
-    return attempts.findLast((attempt) => attempt.outcome === 'accepted' || attempt.outcome === 'unknown');
-}
-export async function terminalWakeAttempt(attention, opts = {}) {
-    return terminalWakeEvidence(await readWakeAttempts({ attention, ...opts }));
-}
-export function isWakeRouteAttemptable(route, attempts) {
-    if (terminalWakeEvidence(attempts) !== undefined)
-        return false;
-    const failed = attempts.findLast((attempt) => attempt.routeKind === route.kind && attempt.outcome === 'failed');
-    return failed === undefined || route.updatedAt > failed.at;
-}
-export function hasAttemptableWakeRoute(routes, attempts) {
-    return routes.some((route) => isWakeRouteAttemptable(route, attempts));
-}
-export async function nextWakeAttemptNumber(attention, opts = {}) {
-    return (await readWakeAttempts({ attention, ...opts })).reduce((highest, attempt) => Math.max(highest, attempt.attemptN), 0) + 1;
+        return scoped;
+    const keys = await Promise.all(scoped.map((attempt) => wakeAttentionKey(attempt.attention)));
+    return scoped.filter((_, index) => keys[index] === expected);
 }
 function redact(value, secret) {
     if (typeof value === 'string') {
@@ -120,24 +56,6 @@ function redact(value, secret) {
     }
     return value;
 }
-async function toRow(attempt, env) {
-    const safe = redact(attempt, env.PASEO_PASSWORD);
-    return {
-        v: 1,
-        ts: safe.at,
-        attention: {
-            square_path: await canonicalSquarePath(safe.attention.squarePath),
-            act_id: formatActivityId(safe.attention.actIndex),
-            recipient: safe.attention.recipient,
-        },
-        route_kind: safe.routeKind,
-        outcome: safe.outcome,
-        ...(safe.signature === undefined ? {} : { signature: safe.signature }),
-        attempt_n: safe.attemptN,
-        ...(safe.message === undefined ? {} : { message: safe.message }),
-        ...(safe.diagnostic === undefined ? {} : { diagnostic: safe.diagnostic }),
-    };
-}
 export async function recordWakeAttempt(attempt, env = process.env) {
     const value = { ...attempt, at: attempt.at ?? Date.now() };
     if (!isWakeRouteKind(value.routeKind))
@@ -145,25 +63,24 @@ export async function recordWakeAttempt(attempt, env = process.env) {
     if (value.outcome !== 'accepted' && !value.signature) {
         throw new Error(`${value.outcome} wake attempts require a transport signature.`);
     }
-    const file = wakeAttemptsPath(env);
-    await withFileLock(`${file}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, async () => {
-        await writeRows(file, [...await readRowsFromFile(file, value.at), await toRow(value, env)]);
-    });
+    const safe = redact(value, env.PASEO_PASSWORD);
+    await ledger(env).appendWakeAttempt({ location: safe.attention.squarePath, participant: safe.attention.recipient, session: safe.session ?? safe.signature ?? `route:${safe.routeKind}`, activity: formatActivityId(safe.attention.actIndex), kind: 'wake', outcome: safe.outcome, routeKind: safe.routeKind, signature: safe.signature, attemptN: safe.attemptN, message: safe.message, diagnostic: safe.diagnostic, at: safe.at });
     return value;
 }
 export async function recordRecoveredUnknown(attention, lease, env = process.env, at = Date.now()) {
     const routeKind = lease.routeKind;
     if (lease.attemptN === undefined || !isWakeRouteKind(routeKind))
         return undefined;
-    const file = wakeAttemptsPath(env);
-    return withFileLock(`${file}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, async () => {
-        const rows = await readRowsFromFile(file, at);
+    const rows = await readRows(env, at);
+    {
         const expected = await wakeAttentionKey(attention);
         const attempts = [];
-        for (const row of rows) {
-            const attempt = await fromRow(row);
-            if (await wakeAttentionKey(attempt.attention) === expected)
-                attempts.push(attempt);
+        for (const attempt of rows) {
+            if (await wakeAttentionKey(attempt.attention) !== expected)
+                continue;
+            if (lease.session !== undefined && attempt.session !== lease.session)
+                continue;
+            attempts.push(attempt);
         }
         const terminal = terminalWakeEvidence(attempts);
         if (terminal !== undefined)
@@ -177,7 +94,7 @@ export async function recordRecoveredUnknown(attention, lease, env = process.env
             attemptN: lease.attemptN,
             message: 'The notification worker ended after dispatch began; transport acceptance is unknown.',
         };
-        await writeRows(file, [...rows, await toRow(value, env)]);
+        await ledger(env).appendWakeAttempt({ location: attention.squarePath, participant: attention.recipient, session: lease.session ?? value.signature, activity: formatActivityId(attention.actIndex), kind: 'wake', outcome: 'unknown', routeKind, signature: value.signature, attemptN: value.attemptN, message: value.message, at });
         return value;
-    });
+    }
 }

package/dist/wake-evidence.d.ts

@@ -1,21 +1,9 @@
-import { type WakeRoute } from './model.js';
-import { type DeliveryModel } from './delivery.js';
-import { type SquareState } from './model.js';
-import { type WakeAttempt } from './wake-attempts.js';
-export interface WakeEvidence {
-    delivered: boolean;
-    notified: boolean;
-    presented: boolean;
-    attempts: WakeAttempt[];
-    terminal?: WakeAttempt;
-    attemptableRoutes: WakeRoute[];
-}
-export interface WakeEvidenceProjection {
-    evidence(recipient: string, actIndex: number): WakeEvidence;
-}
-/** Capture the primary wake facts once and derive any number of eligibility decisions from them. */
+import type { SquareState } from './model.js';
+import { wakeIsEligible, type WakeEvidence, type WakeEvidenceProjection } from './square-projections.js';
+import type { DeliveryModel } from './delivery.js';
+export type { WakeEvidence, WakeEvidenceProjection };
+export { wakeIsEligible };
+/** Adapter entry: open the artifact, assemble host ports, and project wake evidence. */
 export declare function wakeEvidenceProjection(squarePath: string, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidenceProjection>;
 export declare function wakeEvidenceProjectionFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, delivery?: DeliveryModel): Promise<WakeEvidenceProjection>;
-/** Project every wake decision from the same primary evidence. */
 export declare function wakeEvidence(squarePath: string, recipient: string, actIndex: number, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidence>;
-export declare function wakeIsEligible(evidence: WakeEvidence): boolean;

package/dist/wake-evidence.js

@@ -1,95 +1,32 @@
-import { deriveDeliveryModel } from './delivery.js';
-import { nameKey } from './model.js';
-import { readPresentedAttentions } from './presented.js';
-import { canonicalSquarePath, readActiveBindings } from './registry.js';
-import { readWakeRoutes } from './routes.js';
-import { isWakeRouteAttemptable, readWakeAttempts, terminalWakeEvidence, } from './wake-attempts.js';
+import path from 'node:path';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { observationFor } from './runtime.js';
-import { entryPresentation } from './views.js';
-async function attentionKey(squarePath, recipient, actIndex) {
-    return JSON.stringify([await canonicalSquarePath(squarePath), nameKey(recipient), actIndex]);
+import { projectWakeEvidenceFromState, wakeIsEligible, } from './square-projections.js';
+export { wakeIsEligible };
+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,
+        readableScopes: ['user'],
+        writableScope: 'user',
+    });
 }
-async function projectionFromState(squarePath, state, now, env, delivery = deriveDeliveryModel(state)) {
-    const canonicalPath = await canonicalSquarePath(squarePath);
-    const owners = new Map();
-    for (const binding of await readActiveBindings(now)) {
-        if (binding.squarePath !== canonicalPath)
-            continue;
-        const key = nameKey(binding.name);
-        const recipientOwners = owners.get(key) ?? new Set();
-        recipientOwners.add(binding.ownerId);
-        owners.set(key, recipientOwners);
-    }
-    const routesByOwner = new Map();
-    for (const route of await readWakeRoutes({ freshOnly: true, now, env })) {
-        const routes = routesByOwner.get(route.ownerId) ?? [];
-        routes.push(route);
-        routesByOwner.set(route.ownerId, routes);
-    }
-    const attemptsByAttention = new Map();
-    for (const attempt of await readWakeAttempts({ env, now })) {
-        const key = await attentionKey(attempt.attention.squarePath, attempt.attention.recipient, attempt.attention.actIndex);
-        const attempts = attemptsByAttention.get(key) ?? [];
-        attempts.push(attempt);
-        attemptsByAttention.set(key, attempts);
-    }
-    const presentedByAttention = new Map();
-    for (const presented of await readPresentedAttentions(env, now)) {
-        const key = await attentionKey(presented.squarePath, presented.name, presented.actIndex);
-        const presentedOwners = presentedByAttention.get(key) ?? new Set();
-        presentedOwners.add(presented.ownerId);
-        presentedByAttention.set(key, presentedOwners);
-    }
-    return {
-        evidence(recipient, actIndex) {
-            const recipientOwners = owners.get(nameKey(recipient)) ?? new Set();
-            const key = JSON.stringify([canonicalPath, nameKey(recipient), actIndex]);
-            const attempts = attemptsByAttention.get(key) ?? [];
-            const terminal = terminalWakeEvidence(attempts);
-            const routes = [...recipientOwners].flatMap((ownerId) => routesByOwner.get(ownerId) ?? []);
-            const presented = [...(presentedByAttention.get(key) ?? [])]
-                .some((ownerId) => recipientOwners.has(ownerId));
-            return {
-                delivered: delivery.isSeen(recipient, actIndex),
-                notified: (() => {
-                    const observation = observationFor(state, recipient, actIndex);
-                    return observation?.state === 'notified'
-                        && observation.ownerId !== undefined
-                        && recipientOwners.has(observation.ownerId);
-                })(),
-                presented,
-                attempts,
-                ...(terminal === undefined ? {} : { terminal }),
-                attemptableRoutes: terminal === undefined
-                    ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
-                    : [],
-            };
-        },
-    };
-}
-/** Capture the primary wake facts once and derive any number of eligibility decisions from them. */
+/** Adapter entry: open the artifact, assemble host ports, and project wake evidence. */
 export async function wakeEvidenceProjection(squarePath, now, env) {
-    const square = await openSquare(squarePath, { clock: () => now });
+    const square = await openSquare(squarePath, { clock: () => now, hostLedger: hostLedgerForEnv(env), env });
     try {
-        const { state } = await entryPresentation(square, '');
-        return projectionFromState(squarePath, state, now, env);
+        const { state } = await square.artifact.read();
+        return projectWakeEvidenceFromState({ location: squarePath, state, hostLedger: square.hostLedger, now });
     }
     finally {
         await closeOpenSquare(square);
     }
 }
 export function wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery) {
-    return projectionFromState(squarePath, state, now, env, delivery);
+    return projectWakeEvidenceFromState({ location: squarePath, state, hostLedger: hostLedgerForEnv(env), now, delivery });
 }
-/** Project every wake decision from the same primary evidence. */
 export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {
     return (await wakeEvidenceProjection(squarePath, now, env)).evidence(recipient, actIndex);
 }
-export function wakeIsEligible(evidence) {
-    return !evidence.delivered
-        && !evidence.notified
-        && evidence.terminal === undefined
-        && evidence.attemptableRoutes.length > 0;
-}

package/dist/wakes.d.ts

@@ -1,4 +1,4 @@
-import { type NotifyLease, type WakeRouteKind, type WatchLease, type WatchOptions } from './model.js';
+import { type WatchLease, type WatchOptions } from './model.js';
 import type { OpenSquare } from './open-square.js';
 export type WatchLeaseStart = {
     readonly type: 'started';
@@ -20,21 +20,7 @@ export type WatchLeasePulse = {
     readonly type: 'sleep';
     readonly heartbeatAt?: number;
 };
-export type NotifyLeaseClaim = {
-    readonly type: 'delivered';
-} | {
-    readonly type: 'busy';
-} | {
-    readonly type: 'ambiguous';
-    readonly lease: NotifyLease;
-} | {
-    readonly type: 'acquired';
-    readonly leaseId: string;
-};
-export declare function acquireWatchLease(square: OpenSquare, name: string, leaseId: string, options: WatchOptions, ownerId?: string): Promise<WatchLeaseStart>;
+export declare function acquireWatchLease(square: OpenSquare, name: string, leaseId: string, options: WatchOptions): Promise<WatchLeaseStart>;
 export declare function pulseWatchLease(square: OpenSquare, name: string, leaseId: string, options: WatchOptions, heartbeatDue: boolean): Promise<WatchLeasePulse>;
 export declare function releaseWatchLease(square: OpenSquare, name: string, leaseId: string | undefined): Promise<void>;
 export declare function ownsWatchLease(square: OpenSquare, name: string, leaseId: string): Promise<boolean>;
-export declare function claimNotificationLease(square: OpenSquare, recipient: string, actIndex: number, leaseId: string, leaseMs: number): Promise<NotifyLeaseClaim>;
-export declare function transitionNotificationLease(square: OpenSquare, recipient: string, actIndex: number, leaseId: string, phase: NotifyLease['phase'], leaseMs: number, routeKind?: WakeRouteKind, attemptN?: number): Promise<boolean>;
-export declare function releaseNotificationLease(square: OpenSquare, recipient: string, actIndex: number, leaseId: string): Promise<void>;

package/dist/wakes.js

@@ -1,26 +1,22 @@
-import { formatActivityId } from './square-core.js';
-import { isActivitySeen } from './delivery.js';
-import { nameKey } from './model.js';
 import { resolveKnownName } from './decisions.js';
 import { WATCH_STALE_MS, currentHold, freshWatchLease, removeWatchLease, watchTerminalStatus, writeWatchLease } from './runtime.js';
 function filter(options) {
     return { ...(options.participants === undefined ? {} : { participants: [...options.participants] }), ...(options.mention === undefined ? {} : { mention: options.mention }) };
 }
-function notificationKey(recipient, index) { return JSON.stringify([formatActivityId(index), nameKey(recipient)]); }
-export async function acquireWatchLease(square, name, leaseId, options, ownerId) {
+export async function acquireWatchLease(square, name, leaseId, options) {
     const at = square.clock();
-    return square.cell.transact((state) => {
+    return square.artifact.transact((state) => {
         const known = resolveKnownName(state, name);
         const existing = freshWatchLease(state, known, at);
         if (existing !== undefined && !options.replace)
             return { result: { type: 'active', lease: existing } };
-        writeWatchLease(state, known, { leaseId, ...(ownerId === undefined ? {} : { ownerId }), heartbeatAt: at, expiresAt: at + WATCH_STALE_MS, ...(Object.keys(filter(options)).length === 0 ? {} : { filter: filter(options) }) });
+        writeWatchLease(state, known, { leaseId, heartbeatAt: at, expiresAt: at + WATCH_STALE_MS, ...(Object.keys(filter(options)).length === 0 ? {} : { filter: filter(options) }) });
         return { state, result: { type: 'started', leaseId, replaced: existing !== undefined, heartbeatAt: at } };
     });
 }
 export async function pulseWatchLease(square, name, leaseId, options, heartbeatDue) {
     const at = square.clock();
-    return square.cell.transact((state) => {
+    return square.artifact.transact((state) => {
         const known = resolveKnownName(state, name);
         const lease = freshWatchLease(state, known, at);
         if (lease?.leaseId !== leaseId)
@@ -32,29 +28,13 @@ export async function pulseWatchLease(square, name, leaseId, options, heartbeatD
             return { result: { type: 'terminal', status: terminal } };
         if (!heartbeatDue)
             return { result: { type: 'sleep' } };
-        writeWatchLease(state, known, { leaseId, ...(lease.ownerId === undefined ? {} : { ownerId: lease.ownerId }), heartbeatAt: at, expiresAt: at + WATCH_STALE_MS, ...(Object.keys(filter(options)).length === 0 ? {} : { filter: filter(options) }) });
+        writeWatchLease(state, known, { leaseId, heartbeatAt: at, expiresAt: at + WATCH_STALE_MS, ...(Object.keys(filter(options)).length === 0 ? {} : { filter: filter(options) }) });
         return { state, result: { type: 'sleep', heartbeatAt: at } };
     });
 }
 export async function releaseWatchLease(square, name, leaseId) {
     if (leaseId === undefined)
         return;
-    await square.cell.transact((state) => { const known = resolveKnownName(state, name); return removeWatchLease(state, known, leaseId) ? { state, result: undefined } : { result: undefined }; });
+    await square.artifact.transact((state) => { const known = resolveKnownName(state, name); return removeWatchLease(state, known, leaseId) ? { state, result: undefined } : { result: undefined }; });
 }
-export async function ownsWatchLease(square, name, leaseId) { const { state } = await square.cell.read(); return freshWatchLease(state, resolveKnownName(state, name), square.clock())?.leaseId === leaseId; }
-export async function claimNotificationLease(square, recipient, actIndex, leaseId, leaseMs) {
-    const at = square.clock();
-    const key = notificationKey(recipient, actIndex);
-    return square.cell.transact((state) => { const known = resolveKnownName(state, recipient); if (isActivitySeen(state, known, actIndex))
-        return { result: { type: 'delivered' } }; const existing = state.runtime.notifyLeases[key]; if (existing !== undefined && existing.expiresAt > at)
-        return { result: { type: 'busy' } }; if (existing?.phase === 'dispatching')
-        return { result: { type: 'ambiguous', lease: existing } }; state.runtime.notifyLeases[key] = { leaseId, expiresAt: at + leaseMs, phase: 'claimed' }; return { state, result: { type: 'acquired', leaseId } }; });
-}
-export async function transitionNotificationLease(square, recipient, actIndex, leaseId, phase, leaseMs, routeKind, attemptN) {
-    const at = square.clock();
-    const key = notificationKey(recipient, actIndex);
-    return square.cell.transact((state) => { if (state.runtime.notifyLeases[key]?.leaseId !== leaseId)
-        return { result: false }; state.runtime.notifyLeases[key] = { leaseId, expiresAt: at + leaseMs, phase, ...(routeKind === undefined ? {} : { routeKind }), ...(attemptN === undefined ? {} : { attemptN }) }; return { state, result: true }; });
-}
-export async function releaseNotificationLease(square, recipient, actIndex, leaseId) { const key = notificationKey(recipient, actIndex); await square.cell.transact((state) => { if (state.runtime.notifyLeases[key]?.leaseId !== leaseId)
-    return { result: undefined }; delete state.runtime.notifyLeases[key]; return { state, result: undefined }; }); }
+export async function ownsWatchLease(square, name, leaseId) { const { state } = await square.artifact.read(); return freshWatchLease(state, resolveKnownName(state, name), square.clock())?.leaseId === leaseId; }

package/dist/watch.js

@@ -7,7 +7,7 @@ import { openParticipant } from './square-wiring.js';
 import { resolveParticipant, watchPresentation } from './views.js';
 import { acquireWatchLease, ownsWatchLease, pulseWatchLease, releaseWatchLease } from './wakes.js';
 import { renderWatchForceTakeover, renderWatchAlreadyActive, renderWatchOutput, renderWatchReplaced, renderWatchStatus, participantCommandPrefix, withPathOutput, } from './presentation.js';
-import { hasAutomaticDeliveryIdentity, localParticipantOwner } from './registry.js';
+import { hasAutomaticDeliveryIdentity } from './registry.js';
 import { parseActivityId } from './square-core.js';
 function watchStatusExitCode(status) {
     return status === 'capped' ? 1 : 0;
@@ -87,8 +87,7 @@ async function finishWatchResult(square, squarePath, name, result, leaseId, idle
 }
 async function beginWatch(square, squarePath, name, opts) {
     const id = leaseId();
-    const ownerId = await localParticipantOwner(squarePath, name);
-    return acquireWatchLease(square, name, id, opts, ownerId);
+    return acquireWatchLease(square, name, id, opts);
 }
 async function endWatch(square, name, id) {
     await releaseWatchLease(square, name, id);

package/extensions/square-pi.js

@@ -1,11 +1,16 @@
 import { presentPendingAtBoundary, renderPendingAtBoundary } from '../dist/boundary-presentation.js';
 import { automaticSessionEnd, automaticSessionStart } from '../dist/automatic-session.js';
 import { waitForSessionPending } from '../dist/inbox.js';
-import { lookupSessionBindings } from '../dist/registry.js';
+import { projectSessionBindings } from '../dist/square-projections.js';
+import { createHostLedgerPort } from '../dist/host-ledger-file-adapter.js';
 
 const PI_SEND_TIMEOUT_MS = 5_000;
 const DEFAULT_PI_BOUNDARY_TIMEOUT_MS = 2_000;
 
+function sessionBindings(sessionId) {
+  return projectSessionBindings({ hostLedger: createHostLedgerPort(), sessionId });
+}
+
 function piBoundaryTimeoutMs() {
   const configured = Number.parseInt(process.env.SQUARE_PI_BOUNDARY_TIMEOUT_MS || '', 10);
   return Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_PI_BOUNDARY_TIMEOUT_MS;
@@ -84,7 +89,7 @@ export default function squarePiExtension(pi) {
 
   const wake = async (piContext, token, signal) => {
     while (sessionId !== undefined && token === generation && !signal.aborted) {
-      if ((await lookupSessionBindings(sessionId)).length === 0) {
+      if ((await sessionBindings(sessionId)).length === 0) {
         await pause(signal, 1_000);
         continue;
       }

package/package.json

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

package/skills/brainstorm/SKILL.md

@@ -53,7 +53,7 @@ square --location <square> --as <name> done - <<'EOF'
 ...
 EOF
 
-For complete history: square --location <square> history --all --full
+For complete history, follow the activity-id continuation commands printed by `history`.
 
 Every activity must address at least one participant with @name. Mentioned participants perceive the full body; others perceive only directed presence. Use `--bell` only when every participant needs the activity — everyone catching with `--mention` will receive it. Precise history queries may still read original archive bodies.
 
@@ -117,7 +117,7 @@ While held, participant expression and catch pause. Join, done, status, and hist
 When participants are done, collect the public activities:
 
 ```bash
-square --location <square> history --all --full        # complete public history
+square --location <square> history --no-truncate      # expand preview bodies
 square --location <square> status
 ```
 

package/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.
 
@@ -74,11 +74,11 @@ EOF
 ```bash
 square --location <square> --as <name> catch --now       # take in what is pending
 square --location <square> --as <name> catch --idle 30m  # wait until something relevant lands, or 30m of quiet
-square --location <square> --as <name> catch --mention   # filter to mentions
-square --location <square> --as <name> catch --from <names>
+square --location <square> --as <name> catch --now --mention       # take in pending mentions
+square --location <square> --as <name> catch --now --from <names>  # take in pending activity from named participants
 ```
 
-Waiting with `catch --idle` is the normal way to stay present between expressions — `join` prints the exact command to keep open. Do not build a polling loop.
+Every catch needs exactly one mode: `--now` or `--idle <duration>`. `--mention` and `--from` filter either mode; they do not replace it. Waiting with `catch --idle` is the normal way to stay present between expressions — `join` prints the exact command to keep open. Do not build a polling loop.
 
 ## Listen
 
@@ -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