@astrosheep/square 0.3.29 → 0.3.31

package/dist/presence.js

@@ -1,49 +1,21 @@
-import { extractMentions, formatActivityId } from './square-core.js';
-import { deliveryDelta, directedPeerSays, matchesFeedFilter } from './activity-feed.js';
-import { deriveDeliveryModel, markSeenNotifications } from './delivery.js';
-import { SquareError } from './model.js';
+import { deriveDeliveryModel } from './delivery.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { resolveKnownName } from './decisions.js';
 import { recordObservation } from './runtime.js';
-function expose(squareState, activity, viewer, delivery) {
-    if (activity.kind === 'read' || activity.actor === undefined)
-        throw new Error(`Cannot expose stored activity ${formatActivityId(activity.index)}`);
-    const perception = delivery.perceive(activity, viewer);
-    const result = { id: formatActivityId(activity.index), at: activity.at, kind: activity.kind, actor: activity.actor, mentions: activity.kind === 'say' ? extractMentions(activity.body) : [], ...('body' in activity && activity.body !== undefined ? { body: activity.body } : {}), ...('target' in activity ? { target: activity.target } : {}), ...(activity.kind === 'say' && activity.reply !== undefined ? { reply: formatActivityId(activity.reply) } : {}) };
-    if (perception === 'full' || !('body' in result))
-        return { ...result, perception };
-    const { body: _body, ...withoutBody } = result;
-    return { ...withoutBody, perception };
+import { catchUp as actionCatchUp } from './square-actions.js';
+function operationContext(square) {
+    return 'artifact' in square
+        ? { artifact: square.artifact, clock: square.clock }
+        : { artifact: square.cell, clock: square.clock };
 }
 export async function catchUp(square, name, options = {}, deriveDelivery = deriveDeliveryModel) {
-    const idle = options.idle ?? 0;
-    if (!Number.isFinite(idle) || idle < 0)
-        throw new SquareError('invalid_args', 'Catch idle duration must be a non-negative number');
-    const deadline = Date.now() + idle;
-    while (true) {
-        const attempt = await square.cell.transact((state, version) => {
-            const at = square.clock();
-            const viewer = resolveKnownName(state, name);
-            const delivery = deriveDelivery(state);
-            const delta = deliveryDelta(state, viewer, delivery);
-            const filter = { ...(options.from === undefined ? {} : { participants: [...options.from] }), ...(options.mention === true ? { mention: viewer } : {}) };
-            const delivered = directedPeerSays(state, delta, viewer, delivery).filter((activity) => matchesFeedFilter(activity, filter))
-                .filter((activity, index, activities) => activities.findIndex((candidate) => candidate.index === activity.index) === index)
-                .sort((left, right) => left.index - right.index);
-            const seenChanged = delivered.length === 0 ? false : markSeenNotifications(state, viewer, delivered, at, delivery);
-            const cursor = delivery.cursorFor(viewer);
-            return { ...(seenChanged ? { state } : {}), result: { version, caught: { activities: delivered.map((activity) => expose(state, activity, viewer, delivery)), consumedThrough: cursor < 0 ? null : formatActivityId(cursor), idleExpired: false } } };
-        });
-        if (attempt.caught.activities.length > 0 || idle === 0)
-            return attempt.caught;
-        const remaining = deadline - Date.now();
-        if (remaining <= 0 || !await square.cell.changed(attempt.version, remaining))
-            return { ...attempt.caught, idleExpired: true };
-    }
+    const project = deriveDelivery === deriveDeliveryModel
+        ? undefined
+        : (state) => deriveDelivery(state);
+    return actionCatchUp(operationContext(square), name, options, project);
 }
 /** Commit seen only for complete, actually rendered boundary bodies. */
-export async function markBoundarySeen(squarePath, name, ownerId, actIndexes, at = Date.now()) {
+export async function markBoundarySeen(squarePath, name, actIndexes, at = Date.now()) {
     let square;
     try {
         square = await openSquare(squarePath);
@@ -52,10 +24,10 @@ export async function markBoundarySeen(squarePath, name, ownerId, actIndexes, at
         return;
     }
     try {
-        await square.cell.transact((state) => {
+        await square.artifact.transact((state) => {
             let changed = false;
             for (const index of actIndexes)
-                changed = recordObservation(state, name, index, 'seen', at, ownerId) || changed;
+                changed = recordObservation(state, name, index, 'seen', at) || changed;
             return changed ? { state, result: undefined } : { result: undefined };
         });
     }
@@ -63,8 +35,3 @@ export async function markBoundarySeen(squarePath, name, ownerId, actIndexes, at
         await closeOpenSquare(square);
     }
 }
-export async function markNotificationNotified(square, name, actIndex, ownerId, at = Date.now()) {
-    await square.cell.transact((state) => recordObservation(state, name, actIndex, 'notified', at, ownerId)
-        ? { state, result: undefined }
-        : { result: undefined });
-}

package/dist/presentation-operations.d.ts

@@ -0,0 +1,3 @@
+import type { PresentationResult, PresentPendingInput } from './ports.js';
+/** Present one pending activity; artifact seen remains the authoritative receipt. */
+export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;

package/dist/presentation-operations.js

@@ -0,0 +1,51 @@
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { deriveDeliveryModel } from './delivery.js';
+import { recordObservation } from './runtime.js';
+/** Present one pending activity; artifact seen remains the authoritative receipt. */
+export async function presentPending(input) {
+    const index = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
+    if (index === undefined)
+        return { presented: false };
+    let before;
+    try {
+        before = await input.artifact.read();
+    }
+    catch {
+        return { presented: false };
+    }
+    const delivery = deriveDeliveryModel(before.state);
+    const item = before.state.acts.find((activity) => activity.index === index);
+    if (item === undefined || delivery.isSeen(input.participant, index) || !delivery.pendingFor(input.participant).some((notification) => notification.item.index === index))
+        return { presented: false };
+    if (input.hostLedger !== undefined && input.session !== undefined) {
+        const claim = await input.hostLedger.claimEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', leaseMs: input.timeoutMs ?? 5000, now: input.now });
+        if (claim.status !== 'acquired')
+            return { presented: false };
+        let current;
+        try {
+            current = await input.artifact.read();
+        }
+        catch {
+            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', now: input.now }).catch(() => undefined);
+            return { presented: false };
+        }
+        if (deriveDeliveryModel(current.state).isSeen(input.participant, index)) {
+            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', now: input.now }).catch(() => undefined);
+            return { presented: false };
+        }
+        try {
+            await input.sink.present(item);
+        }
+        catch (error) {
+            await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: 'failed', message: error instanceof Error ? error.message : String(error), at: input.now });
+            throw error;
+        }
+    }
+    else
+        await input.sink.present(item);
+    if (input.markSeen !== false)
+        await input.artifact.transact((state) => { const changed = recordObservation(state, input.participant, index, 'seen', input.now ?? Date.now()); return changed ? { state, result: undefined } : { result: undefined }; });
+    if (input.hostLedger !== undefined && input.session !== undefined)
+        await input.hostLedger.appendEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', outcome: input.markSeen === false ? 'clipped' : 'presented', ...(input.markSeen === false ? { message: 'presentation clipped' } : {}), at: input.now });
+    return { presented: true, activity: item };
+}

package/dist/presentation.d.ts

@@ -76,8 +76,8 @@ export declare function renderExpressWaiting(opts: ExpressWaitingOptions): strin
 export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPublicTail(squareState: SquareState, events: StoredAct[], lastN: number | null | undefined, now?: number, viewer?: string): string;
 export declare function renderPresenceAnchor(names: readonly string[]): string;
-export declare function renderActivitiesView(squareState: SquareState, visible: StoredAct[], lastN: number | null | undefined, full: boolean | undefined, squarePath: string, viewer?: string, mode?: 'ambient' | 'archive'): string;
-export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, full: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean): string;
+export declare function renderActivitiesView(squareState: SquareState, visible: StoredAct[], lastN: number | null | undefined, noTruncate: boolean | undefined, squarePath: string, viewer?: string, mode?: 'ambient' | 'archive'): string;
+export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: StoredAct) => Perception): string;
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
 export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
 export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;

package/dist/presentation.js

@@ -295,10 +295,10 @@ export function renderPresenceAnchor(names) {
     const participants = names.map((name) => participantIdentity(name)).join(', ');
     return names.length === 1 ? `→ ${participants} was here` : `→ ${participants} were here`;
 }
-export function renderActivitiesView(squareState, visible, lastN, full, squarePath, viewer = '', mode = 'ambient') {
+export function renderActivitiesView(squareState, visible, lastN, noTruncate, squarePath, viewer = '', mode = 'ambient') {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
     const shown = lastN == null ? publicVisible : publicVisible.slice(-lastN);
-    const previewLen = full ? undefined : BODY_PREVIEW_LENGTH;
+    const previewLen = noTruncate ? undefined : BODY_PREVIEW_LENGTH;
     const markers = new Map();
     for (const participant of rosterNames(squareState)) {
         const anchor = lastPresenceAnchor(squareState, participant);
@@ -325,7 +325,7 @@ export function renderActivitiesView(squareState, visible, lastN, full, squarePa
     if (previewLen !== undefined) {
         const truncated = shown.some((act) => act.kind === 'say' && act.body.length > previewLen && (mode === 'archive' || perceiveActivity(squareState, act, viewer) === 'full'));
         if (truncated)
-            chunks.push(`» ${commandPrefix(squarePath)} history --full`);
+            chunks.push(`» ${commandPrefix(squarePath)} history --no-truncate`);
     }
     return chunks.join('\n\n');
 }
@@ -335,7 +335,7 @@ function highlightGrepMatch(text) {
         return text;
     return `\x1b[38;5;222m\x1b[1m${text}\x1b[0m`;
 }
-export function renderGrepActivitiesView(visible, totalMatches, full, squarePath, pattern, fixed = false) {
+export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squarePath, pattern, fixed = false, perception) {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
     if (totalMatches === 0)
         return `○ no activity matched ${quoteShell(pattern)}`;
@@ -344,7 +344,11 @@ export function renderGrepActivitiesView(visible, totalMatches, full, squarePath
     let truncated = false;
     for (const act of publicVisible) {
         const rawBody = act.body ?? '';
-        if (full === true) {
+        if (perception?.(act) === 'presence') {
+            chunks.push(`${actId(act.index)} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${formatTimestamp(act.at)}`);
+            continue;
+        }
+        if (noTruncate === true) {
             const body = rawBody.split('\n').map((line) => `  ${line}`).join('\n');
             chunks.push(`${actId(act.index)} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${formatTimestamp(act.at)}\n${body}`);
             continue;
@@ -365,10 +369,10 @@ export function renderGrepActivitiesView(visible, totalMatches, full, squarePath
         chunks.push(`${actId(act.index)} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${formatTimestamp(act.at)}\n  ${text.trim()}${omitted}`);
     }
     if (publicVisible.length === 1) {
-        chunks.push(`» ${commandPrefix(squarePath)} history --at ${actId(publicVisible[0].index)} -C 2${truncated ? ' --full' : ''}`);
+        chunks.push(`» ${commandPrefix(squarePath)} history --at ${actId(publicVisible[0].index)} -C 2${truncated ? ' --no-truncate' : ''}`);
     }
     else if (truncated && publicVisible.length > 1) {
-        chunks.push(`» ${commandPrefix(squarePath)} history --at ${actId(publicVisible[0].index)} -C 2 --full`);
+        chunks.push(`» ${commandPrefix(squarePath)} history --at ${actId(publicVisible[0].index)} -C 2 --no-truncate`);
     }
     return chunks.join('\n\n');
 }

package/dist/presented.d.ts

@@ -1,13 +1,2 @@
-import { type InboxMembership } from './model.js';
-export interface PresentedAttention {
-    ownerId: string;
-    squarePath: string;
-    name: string;
-    actIndex: number;
-}
 export declare function presentedPath(env?: NodeJS.ProcessEnv): string;
-export declare function readPresentedAttentions(env?: NodeJS.ProcessEnv, now?: number): Promise<PresentedAttention[]>;
-export declare function hasPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;
-export declare function hasPresentedAttention(squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;
-export declare function recordPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, at?: number): Promise<void>;
-export declare function presentOnce<T>(sessionId: string, lookup: (sessionId: string) => InboxMembership[] | Promise<InboxMembership[]>, deliver: (inbox: InboxMembership[]) => T | Promise<T>, env?: NodeJS.ProcessEnv, at?: number, signal?: AbortSignal): Promise<T | undefined>;
+export declare function hasPresentedForOwner(sessionId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;

package/dist/presented.js

@@ -1,78 +1,9 @@
-import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { createHash } from 'node:crypto';
-import { withFileLock } from './file-lock.js';
-import { canonicalSquarePath, lookupParticipant, lookupSessionBindings } from './registry.js';
-import { sameName } from './model.js';
-const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-const LOCK_STALE_MS = 5 * 60_000;
-const LOCK_RETRY_MS = 10;
+import { canonicalSquarePath } from './registry.js';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
+import { formatActivityId } from './square-core.js';
+import { projectPresentationEvidence } from './square-projections.js';
 export function presentedPath(env = process.env) { return env.SQUARE_PRESENTED || path.join(os.homedir(), '.square', 'presented.ndjsonl'); }
-async function rowKey(row) { return `${row.owner_id}\u0000${await canonicalSquarePath(row.square_path)}\u0000${row.name.toLocaleLowerCase()}\u0000${row.act_index}`; }
-async function readRows(filePath, now = Date.now()) {
-    let text;
-    try {
-        text = await fs.readFile(filePath, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const cutoff = now - RETENTION_MS;
-    const rows = [];
-    for (const line of text.split('\n')) {
-        if (!line.trim())
-            continue;
-        try {
-            const parsed = JSON.parse(line);
-            if (parsed.v !== 2 || typeof parsed.ts !== 'number' || !Number.isFinite(parsed.ts) || typeof parsed.owner_id !== 'string' || typeof parsed.square_path !== 'string' || typeof parsed.name !== 'string' || typeof parsed.act_index !== 'number' || parsed.ts < cutoff)
-                continue;
-            rows.push(parsed);
-        }
-        catch { }
-    }
-    return rows;
-}
-export async function readPresentedAttentions(env = process.env, now = Date.now()) { return Promise.all((await readRows(presentedPath(env), now)).map(async (row) => ({ ownerId: row.owner_id, squarePath: await canonicalSquarePath(row.square_path), name: row.name, actIndex: row.act_index }))); }
-async function writeRows(filePath, rows) { await fs.mkdir(path.dirname(filePath), { recursive: true }); const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`; await fs.writeFile(temp, rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : ''), { mode: 0o600 }); await fs.rename(temp, filePath); }
-async function membershipKey(membership) { return `${await canonicalSquarePath(membership.squarePath)}\u0000${membership.name.toLocaleLowerCase()}`; }
-async function attentionLockPath(filePath, membership) { return `${filePath}.${createHash('sha256').update(await membershipKey(membership)).digest('hex')}.lock`; }
-async function withAttentionLocks(filePath, inbox, fn, signal) { const lockPaths = [...new Set(await Promise.all(inbox.map((membership) => attentionLockPath(filePath, membership))))].sort(); async function acquire(index) { if (signal?.aborted)
-    throw signal.reason ?? new Error('Presentation aborted'); if (index >= lockPaths.length)
-    return fn(); return withFileLock(lockPaths[index], { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS, signal }, () => acquire(index + 1)); } return acquire(0); }
-async function ownerFor(sessionId, membership) { const squarePath = await canonicalSquarePath(membership.squarePath); const binding = (await lookupSessionBindings(sessionId)).find((candidate) => candidate.squarePath === squarePath && sameName(candidate.name, membership.name)); return binding?.ownerId ?? `session:${sessionId}`; }
-async function selectUnpresented(sessionId, inbox, rows) { const known = new Set(await Promise.all(rows.map(rowKey))); const selected = []; for (const membership of inbox) {
-    const ownerId = await ownerFor(sessionId, membership);
-    const notifications = [];
-    for (const notification of membership.notifications) {
-        if (!known.has(await rowKey({ owner_id: ownerId, square_path: membership.squarePath, name: membership.name, act_index: notification.actIndex })))
-            notifications.push(notification);
-    }
-    if (notifications.length > 0)
-        selected.push({ membership: { ...membership, notifications }, ownerId });
-} return selected; }
-export async function hasPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env, now = Date.now()) { const resolved = await canonicalSquarePath(squarePath); for (const row of await readRows(presentedPath(env), now))
-    if (row.owner_id === ownerId && await canonicalSquarePath(row.square_path) === resolved && sameName(row.name, name) && row.act_index === actIndex)
-        return true; return false; }
-export async function hasPresentedAttention(squarePath, name, actIndex, env = process.env, now = Date.now()) { const ownerIds = new Set((await lookupParticipant(squarePath, name, now)).map((binding) => binding.ownerId)); for (const ownerId of ownerIds)
-    if (await hasPresentedForOwner(ownerId, squarePath, name, actIndex, env, now))
-        return true; return false; }
-export async function recordPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env, at = Date.now()) { const filePath = presentedPath(env); const row = { v: 2, ts: at, owner_id: ownerId, square_path: await canonicalSquarePath(squarePath), name, act_index: actIndex }; await withAttentionLocks(filePath, [{ name, squarePath, notifications: [] }], () => withFileLock(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, async () => { const rows = await readRows(filePath, at); const known = new Set(await Promise.all(rows.map(rowKey))); if (!known.has(await rowKey(row)))
-    await writeRows(filePath, [...rows, row]); })); }
-export async function presentOnce(sessionId, lookup, deliver, env = process.env, at = Date.now(), signal) { const filePath = presentedPath(env); const initial = (await lookup(sessionId)).filter((membership) => membership.notifications.length > 0); if (initial.length === 0)
-    return undefined; const lockedMemberships = new Set(await Promise.all(initial.map(membershipKey))); return withAttentionLocks(filePath, initial, async () => { const current = []; for (const membership of await lookup(sessionId))
-    if (lockedMemberships.has(await membershipKey(membership)))
-        current.push(membership); const selected = await selectUnpresented(sessionId, current, await readRows(filePath, at)); if (selected.length === 0)
-    return undefined; if (signal?.aborted)
-    throw signal.reason ?? new Error('Presentation aborted'); const result = await deliver(selected.map(({ membership }) => membership)); if (signal?.aborted)
-    throw signal.reason ?? new Error('Presentation aborted'); await withFileLock(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS, signal }, async () => { const rows = await readRows(filePath, at); const known = new Set(await Promise.all(rows.map(rowKey))); for (const { membership, ownerId } of selected)
-    for (const notification of membership.notifications) {
-        const row = { v: 2, ts: at, owner_id: ownerId, square_path: await canonicalSquarePath(membership.squarePath), name: membership.name, act_index: notification.actIndex };
-        const key = await rowKey(row);
-        if (!known.has(key)) {
-            rows.push(row);
-            known.add(key);
-        }
-    } await writeRows(filePath, rows); }); return result; }, signal); }
+function evidence(env = process.env) { const file = presentedPath(env); return createHostLedgerPort({ userPath: env.SQUARE_HOST_LEDGER_USER ?? path.dirname(file), writableScope: 'user', readableScopes: ['user'] }); }
+export async function hasPresentedForOwner(sessionId, squarePath, name, actIndex, env = process.env, now = Date.now()) { const resolved = await canonicalSquarePath(squarePath); return (await projectPresentationEvidence({ hostLedger: evidence(env), now, location: resolved, participant: name, sessionId, activity: formatActivityId(actIndex) })).some((row) => row.outcome === 'presented'); }

package/dist/registry.d.ts

@@ -1,5 +1,6 @@
 /** Machine-local participant discovery cache. */
 import { type StoredAct } from './model.js';
+import type { PresenceRecord } from './host-ledger.js';
 export type SessionChannel = 'claude-code' | 'codex' | 'opencode' | 'pi' | 'paseo' | 'unknown';
 export interface RegistryBinding {
     sessionId: string;
@@ -7,34 +8,33 @@ export interface RegistryBinding {
     squarePath: string;
     channel: SessionChannel;
     child: boolean;
-    paseoAgentId?: string;
-    ownerId: string;
+    route?: PresenceRecord['route'];
     updatedAt: number;
 }
 export interface RegistryWriteOptions {
     channel?: SessionChannel;
     child?: boolean;
-    paseoAgentId?: string;
-    ownerId?: string;
+    route?: PresenceRecord['route'];
     at?: number;
+    env?: NodeJS.ProcessEnv;
 }
-export declare function registryPath(): string;
+export declare function registryPath(env?: NodeJS.ProcessEnv): string;
 export declare function canonicalSquarePath(squarePath: string): Promise<string>;
 export declare function recordJoin(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): Promise<void>;
 export declare function recordDone(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): Promise<void>;
-export declare function readActiveBindings(now?: number): Promise<RegistryBinding[]>;
-export declare function lookupSessionBindings(sessionId: string, now?: number): Promise<RegistryBinding[]>;
-export declare function lookupSession(sessionId: string, now?: number): Promise<Array<{
+export declare function readActiveBindings(now?: number, env?: NodeJS.ProcessEnv): Promise<RegistryBinding[]>;
+export declare function lookupSessionBindings(sessionId: string, now?: number, env?: NodeJS.ProcessEnv): Promise<RegistryBinding[]>;
+export declare function lookupSession(sessionId: string, now?: number, env?: NodeJS.ProcessEnv): Promise<Array<{
     name: string;
     squarePath: string;
 }>>;
-export declare function lookupParticipant(squarePath: string, name: string, now?: number): Promise<RegistryBinding[]>;
+export declare function lookupParticipant(squarePath: string, name: string, now?: number, env?: NodeJS.ProcessEnv): Promise<RegistryBinding[]>;
 export declare function localParticipantOwner(squarePath: string, name: string, env?: NodeJS.ProcessEnv, now?: number): Promise<string | undefined>;
 export declare function localParticipantName(squarePath: string, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
 export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
 export type CurrentParticipantBinding = Readonly<{
     created: boolean;
-    ownerId: string;
+    sessionId: string;
 }>;
 export declare function bindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<CurrentParticipantBinding>;
 export declare function unbindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/registry.js

@@ -1,145 +1,80 @@
 /** Machine-local participant discovery cache. */
-import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { nameKey, sameName, SquareError } from './model.js';
+import { sameName, SquareError } from './model.js';
 import { isCurrentlyJoined } from './runtime.js';
-import { publishWakeRoutes, retireOwnerWakeRoutes } from './routes.js';
 import { squareAssignedParticipantName as computeSquareAssignedParticipantName } from './participant-identity.js';
+import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-const COMPACT_BYTES = 64 * 1024;
-const COMPACT_LINES = 1000;
-const VALID_CHANNELS = new Set(['claude-code', 'codex', 'opencode', 'pi', 'paseo', 'unknown']);
 const LOCAL_SESSION_SOURCES = [
     { variable: 'CLAUDE_CODE_SESSION_ID', channel: 'claude-code', child: 'CLAUDE_CODE_CHILD_SESSION' },
     { variable: 'CODEX_THREAD_ID', channel: 'codex' },
     { variable: 'OPENCODE_SESSION_ID', channel: 'opencode' },
     { variable: 'SQUARE_PI_SESSION_ID', channel: 'pi' },
 ];
-export function registryPath() { return process.env.SQUARE_REGISTRY || path.join(homedir(), '.square', 'sessions.ndjsonl'); }
+export function registryPath(env = process.env) { return env.SQUARE_REGISTRY || path.join(homedir(), '.square', 'sessions.ndjsonl'); }
 export async function canonicalSquarePath(squarePath) { const absolute = path.resolve(squarePath); try {
-    return await fs.realpath(absolute);
+    return await (await import('node:fs/promises')).realpath(absolute);
 }
 catch {
     return absolute;
 } }
-async function bindingKey(sessionId, squarePath, name, channel) { return JSON.stringify([sessionId, await canonicalSquarePath(squarePath), nameKey(name), channel]); }
-async function participantKey(squarePath, name) { return JSON.stringify([await canonicalSquarePath(squarePath), nameKey(name)]); }
-function nextOwnerId() { return randomUUID(); }
-function parseLine(raw, now) {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-    if (value === null || typeof value !== 'object')
-        return undefined;
-    const entry = value;
-    if ((entry.v !== undefined && entry.v !== 1) || (entry.op !== 'join' && entry.op !== 'done') || typeof entry.session_id !== 'string' || entry.session_id === '' || typeof entry.name !== 'string' || entry.name === '' || typeof entry.square_path !== 'string' || entry.square_path === '' || typeof entry.ts !== 'string')
-        return undefined;
-    const updatedAt = Date.parse(entry.ts);
-    if (!Number.isFinite(updatedAt) || updatedAt > now || now - updatedAt > MAX_AGE_MS)
-        return undefined;
-    const channel = entry.channel ?? 'unknown';
-    if (!VALID_CHANNELS.has(channel) || (entry.child !== undefined && entry.child !== true) || (entry.paseo_agent_id !== undefined && typeof entry.paseo_agent_id !== 'string') || (entry.owner_id !== undefined && typeof entry.owner_id !== 'string'))
-        return undefined;
-    return { ...entry, v: 1, channel };
+function ledger(env, writableScope = 'local') { const root = path.dirname(registryPath(env)); return createHostLedgerPort({ userPath: env.SQUARE_HOST_LEDGER_USER ?? (env.SQUARE_REGISTRY ? root : path.join(homedir(), '.square', 'host-ledger')), localPath: env.SQUARE_HOST_LEDGER_LOCAL ?? (env.SQUARE_REGISTRY ? root : path.join(process.cwd(), '.square', 'host-ledger')), writableScope }); }
+function toBinding(record) { return { sessionId: record.session, name: record.participant, squarePath: record.location, channel: record.channel, child: false, ...(record.route === undefined ? {} : { route: record.route }), updatedAt: record.updatedAt ?? 0 }; }
+async function activeBindings(now, env) { return (await ledger(env).listPresence({ now, scopes: ['user', 'local'] })).map(toBinding).sort((a, b) => b.updatedAt - a.updatedAt); }
+async function writePresence(sessionId, name, squarePath, options, done, scope = 'local') { if (!sessionId || !name || !squarePath)
+    return; const env = options.env ?? process.env; const channel = options.channel ?? 'unknown'; const port = ledger(env, scope); const location = await canonicalSquarePath(squarePath); if (done)
+    await port.removePresence({ location, participant: name, session: sessionId, channel });
+else
+    await port.ensurePresence({ location, participant: name, session: sessionId, channel, route: options.route, updatedAt: options.at ?? Date.now() }); }
+export function recordJoin(sessionId, name, squarePath, options = {}) { return writePresence(sessionId, name, squarePath, options, false); }
+export async function recordDone(sessionId, name, squarePath, options = {}) {
+    await writePresence(sessionId, name, squarePath, options, true);
+    await writePresence(sessionId, name, squarePath, options, true, 'user');
 }
-async function foldRegistry(raw, now) {
-    const state = new Map();
-    const owners = new Map();
-    let order = 0;
-    for (const line of raw.split('\n')) {
-        if (!line.trim())
-            continue;
-        const entry = parseLine(line, now);
-        if (!entry)
-            continue;
-        order++;
-        const ownerId = entry.owner_id ?? `legacy:${order}`;
-        state.set(await bindingKey(entry.session_id, entry.square_path, entry.name, entry.channel), { entry, updatedAt: Date.parse(entry.ts), ownerId });
-        if (entry.op === 'join')
-            owners.set(await participantKey(entry.square_path, entry.name), ownerId);
-    }
-    const active = [];
-    for (const { entry, updatedAt, ownerId } of state.values()) {
-        if (entry.op !== 'join' || owners.get(await participantKey(entry.square_path, entry.name)) !== ownerId)
-            continue;
-        active.push({ sessionId: entry.session_id, name: entry.name, squarePath: await canonicalSquarePath(entry.square_path), channel: entry.channel, child: entry.child === true, ...(entry.paseo_agent_id ? { paseoAgentId: entry.paseo_agent_id } : {}), ownerId, updatedAt });
-    }
-    return active.sort((a, b) => b.updatedAt - a.updatedAt);
-}
-async function writeRegistryBindings(filePath, bindings) { const compacted = bindings.slice().reverse().map((binding) => JSON.stringify({ v: 1, ts: new Date(binding.updatedAt).toISOString(), op: 'join', channel: binding.channel, session_id: binding.sessionId, name: binding.name, square_path: binding.squarePath, ...(binding.child ? { child: true } : {}), ...(binding.paseoAgentId ? { paseo_agent_id: binding.paseoAgentId } : {}), owner_id: binding.ownerId })).join('\n'); const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`; await fs.writeFile(temporary, compacted === '' ? '' : `${compacted}\n`, { mode: 0o600 }); await fs.rename(temporary, filePath); }
-async function maybeCompactRegistry(filePath, now) { let stat; try {
-    stat = await fs.stat(filePath);
-}
-catch (error) {
-    if (error.code === 'ENOENT')
-        return;
-    throw error;
-} if (stat.size <= COMPACT_BYTES)
-    return; const raw = await fs.readFile(filePath, 'utf8'); if (stat.size > COMPACT_BYTES || raw.split('\n').filter(Boolean).length > COMPACT_LINES)
-    await writeRegistryBindings(filePath, await foldRegistry(raw, now)); }
-async function appendRegistryLine(entry, now) { const filePath = registryPath(); await fs.mkdir(path.dirname(filePath), { recursive: true }); await maybeCompactRegistry(filePath, now); await fs.appendFile(filePath, `${JSON.stringify(entry)}\n`, { mode: 0o600 }); }
-async function writeLifecycle(op, sessionId, name, squarePath, options) { if (!sessionId || !name || !squarePath)
-    return; const at = options.at ?? Date.now(); if (!Number.isFinite(at))
-    return; try {
-    await appendRegistryLine({ v: 1, ts: new Date(at).toISOString(), op, channel: options.channel ?? 'unknown', session_id: sessionId, name, square_path: await canonicalSquarePath(squarePath), ...(options.child ? { child: true } : {}), ...(options.paseoAgentId ? { paseo_agent_id: options.paseoAgentId } : {}), ...(op === 'join' ? { owner_id: options.ownerId ?? nextOwnerId() } : {}) }, at);
-}
-catch (error) {
-    process.stderr.write(`! square registry write failed: ${error instanceof Error ? error.message : String(error)}\n`);
-} }
-export function recordJoin(sessionId, name, squarePath, options = {}) { return writeLifecycle('join', sessionId, name, squarePath, options); }
-export function recordDone(sessionId, name, squarePath, options = {}) { return writeLifecycle('done', sessionId, name, squarePath, options); }
-export async function readActiveBindings(now = Date.now()) { try {
-    return await foldRegistry(await fs.readFile(registryPath(), 'utf8'), now);
+export async function readActiveBindings(now = Date.now(), env = process.env) { try {
+    return await activeBindings(now, env);
 }
 catch {
     return [];
 } }
-export async function lookupSessionBindings(sessionId, now = Date.now()) { return (await readActiveBindings(now)).filter((binding) => binding.sessionId === sessionId); }
-export async function lookupSession(sessionId, now = Date.now()) { return (await lookupSessionBindings(sessionId, now)).map(({ name, squarePath }) => ({ name, squarePath })); }
-export async function lookupParticipant(squarePath, name, now = Date.now()) { const canonicalPath = await canonicalSquarePath(squarePath); return (await readActiveBindings(now)).filter((binding) => binding.squarePath === canonicalPath && sameName(binding.name, name)); }
+export async function lookupSessionBindings(sessionId, now = Date.now(), env = process.env) { return (await readActiveBindings(now, env)).filter((binding) => binding.sessionId === sessionId); }
+export async function lookupSession(sessionId, now = Date.now(), env = process.env) { return (await lookupSessionBindings(sessionId, now, env)).map(({ name, squarePath }) => ({ name, squarePath })); }
+export async function lookupParticipant(squarePath, name, now = Date.now(), env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); return (await readActiveBindings(now, env)).filter((binding) => binding.squarePath === canonicalPath && sameName(binding.name, name)); }
 export async function localParticipantOwner(squarePath, name, env = process.env, now = Date.now()) { const sessionIds = new Set(localSessionIdentities(env).map((identity) => identity.sessionId)); if (sessionIds.size === 0)
-    return undefined; return (await lookupParticipant(squarePath, name, now)).find((binding) => sessionIds.has(binding.sessionId))?.ownerId; }
-export async function localParticipantName(squarePath, env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); const names = new Set((await Promise.all(localSessionIdentities(env).map(async (identity) => (await lookupSession(identity.sessionId)).filter((item) => item.squarePath === canonicalPath).map((item) => item.name)))).flat()); return names.size === 1 ? [...names][0] : undefined; }
+    return undefined; return (await lookupParticipant(squarePath, name, now, env)).find((binding) => sessionIds.has(binding.sessionId))?.sessionId; }
+export async function localParticipantName(squarePath, env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); const names = new Set((await Promise.all(localSessionIdentities(env).map(async (identity) => (await lookupSession(identity.sessionId, Date.now(), env)).filter((item) => item.squarePath === canonicalPath).map((item) => item.name)))).flat()); return names.size === 1 ? [...names][0] : undefined; }
 export function squareAssignedParticipantName(env = process.env) { return computeSquareAssignedParticipantName(env); }
 export async function bindCurrentParticipant(squarePath, name, env = process.env) { if (squareAssignedParticipantName(env) !== name)
-    throw new SquareError('invalid_args', `The current session is not assigned ${name}`); const localOwner = await localParticipantOwner(squarePath, name, env); if (localOwner !== undefined)
-    return { created: false, ownerId: localOwner }; if ((await lookupParticipant(squarePath, name)).at(0) !== undefined)
-    throw new SquareError('already_joined', `${name} is already bound to another session`); await recordLocalJoin(name, squarePath, env); const ownerId = await localParticipantOwner(squarePath, name, env); if (ownerId === undefined)
-    throw new Error(`Current participant binding did not commit for ${name}`); return { created: true, ownerId }; }
-export async function unbindCurrentParticipant(squarePath, name, env = process.env) { const identities = new Set(localSessionIdentities(env).map((identity) => identity.sessionId)); const current = (await lookupParticipant(squarePath, name)).filter((binding) => identities.has(binding.sessionId)); for (const binding of current)
+    throw new SquareError('invalid_args', `The current session is not assigned ${name}`); const sessionId = await localParticipantOwner(squarePath, name, env); if (sessionId !== undefined)
+    return { created: false, sessionId }; if ((await lookupParticipant(squarePath, name, Date.now(), env)).at(0) !== undefined)
+    throw new SquareError('already_joined', `${name} is already bound to another session`); await recordLocalJoin(name, squarePath, env); const currentSessionId = await localParticipantOwner(squarePath, name, env); if (currentSessionId === undefined)
+    throw new Error(`Current participant binding did not commit for ${name}`); return { created: true, sessionId: currentSessionId }; }
+export async function unbindCurrentParticipant(squarePath, name, env = process.env) { const identities = new Set(localSessionIdentities(env).map((identity) => identity.sessionId)); const current = (await lookupParticipant(squarePath, name, Date.now(), env)).filter((binding) => identities.has(binding.sessionId)); for (const binding of current)
     await recordSessionDone(binding.sessionId, binding.name, binding.squarePath, binding.channel, env); return current.length > 0; }
 function bindingIsProvablyObsolete(binding, acts) { return acts !== undefined && !isCurrentlyJoined(acts, binding.name); }
-export async function pruneRegistry(readActs, now = Date.now()) { const filePath = registryPath(); let raw; try {
-    raw = await fs.readFile(filePath, 'utf8');
-}
-catch (error) {
-    if (error.code === 'ENOENT')
-        return { removed: 0, kept: 0 };
-    throw error;
-} const active = await foldRegistry(raw, now); const observed = await Promise.all(active.map(async (binding) => ({ binding, acts: await readActs(binding.squarePath) }))); const kept = observed.filter(({ binding, acts }) => !bindingIsProvablyObsolete(binding, acts)).map(({ binding }) => binding); await writeRegistryBindings(filePath, kept); return { removed: active.length - kept.length, kept: kept.length }; }
+export async function pruneRegistry(readActs, now = Date.now()) { const active = await readActiveBindings(now); let removed = 0; for (const binding of active) {
+    if (!bindingIsProvablyObsolete(binding, await readActs(binding.squarePath)))
+        continue;
+    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at: now });
+    removed++;
+} return { removed, kept: active.length - removed }; }
 function addLocalSession(identities, sessionId, channel, child, paseoAgentId) { if (!sessionId || identities.some((identity) => identity.sessionId === sessionId))
     return; identities.push({ sessionId, channel, child, ...(paseoAgentId ? { paseoAgentId } : {}) }); }
 export function localSessionIdentities(env = process.env) { const paseoAgentId = env.PASEO_AGENT_ID?.trim() || undefined; const identities = []; for (const source of LOCAL_SESSION_SOURCES)
     addLocalSession(identities, env[source.variable]?.trim(), source.channel, source.child !== undefined && env[source.child] === '1', paseoAgentId); addLocalSession(identities, paseoAgentId, 'paseo', false, paseoAgentId); return identities; }
 export function hasAutomaticDeliveryIdentity(env = process.env) { return localSessionIdentities(env).length > 0; }
-export async function recordLocalJoin(name, squarePath, env = process.env) { const at = Date.now(); const identities = localSessionIdentities(env); const current = await lookupParticipant(squarePath, name, at); const ownerId = nextOwnerId(); for (const binding of current)
-    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, child: binding.child, ...(binding.paseoAgentId ? { paseoAgentId: binding.paseoAgentId } : {}), at }); for (const identity of identities)
-    await recordJoin(identity.sessionId, name, squarePath, { ...identity, at, ownerId }); await publishWakeRoutes(ownerId, { at, env }); for (const previousOwnerId of new Set(current.map((binding) => binding.ownerId)))
-    if (previousOwnerId !== ownerId)
-        await retireOwnerWakeRoutes(previousOwnerId, { at, env }); }
-export async function recordLocalDone(name, squarePath, env = process.env) { const at = Date.now(); const current = await lookupParticipant(squarePath, name, at); for (const binding of current)
-    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, child: binding.child, ...(binding.paseoAgentId ? { paseoAgentId: binding.paseoAgentId } : {}), at }); for (const ownerId of new Set(current.map((binding) => binding.ownerId)))
-    await retireOwnerWakeRoutes(ownerId, { at, env }); }
-export async function recordSessionJoin(sessionId, name, squarePath, channel, env = process.env) { const at = Date.now(); const ownerId = nextOwnerId(); const current = await lookupParticipant(squarePath, name, at); for (const binding of current) {
-    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, child: binding.child, ...(binding.paseoAgentId ? { paseoAgentId: binding.paseoAgentId } : {}), at });
-    await retireOwnerWakeRoutes(binding.ownerId, { at, env });
-} await recordJoin(sessionId, name, squarePath, { channel, at, ownerId }); await publishWakeRoutes(ownerId, { at, env }); return ownerId; }
-export async function recordSessionDone(sessionId, name, squarePath, channel, env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); const binding = (await lookupSessionBindings(sessionId)).find((item) => item.squarePath === canonicalPath && sameName(item.name, name) && item.channel === channel); if (binding === undefined)
-    return false; const at = Date.now(); await recordDone(sessionId, binding.name, binding.squarePath, { channel, at }); const remaining = (await lookupParticipant(squarePath, binding.name, at)).some((candidate) => candidate.ownerId === binding.ownerId); if (!remaining)
-    await retireOwnerWakeRoutes(binding.ownerId, { at, env }); return true; }
+function callableRoute(sessionId, channel, env) { if (channel === 'codex' && env.CODEX_THREAD_ID?.trim() === sessionId)
+    return { kind: 'codex-queue', address: { threadId: sessionId } }; if (channel === 'paseo' && env.PASEO_AGENT_ID?.trim() === sessionId)
+    return { kind: 'paseo', address: { agentId: sessionId } }; return undefined; }
+export async function recordLocalJoin(name, squarePath, env = process.env) { const at = Date.now(); const identities = localSessionIdentities(env); const current = await lookupParticipant(squarePath, name, at, env); for (const binding of current)
+    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at, env }); for (const identity of identities)
+    await recordJoin(identity.sessionId, name, squarePath, { ...identity, at, env }); }
+export async function recordLocalDone(name, squarePath, env = process.env) { const at = Date.now(); const current = await lookupParticipant(squarePath, name, at, env); for (const binding of current)
+    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at, env }); }
+export async function recordSessionJoin(sessionId, name, squarePath, channel, env = process.env) { const at = Date.now(); const current = await lookupParticipant(squarePath, name, at, env); for (const binding of current) {
+    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at, env });
+    await writePresence(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at, env }, true, 'user');
+} const route = callableRoute(sessionId, channel, env); await recordJoin(sessionId, name, squarePath, { channel, at, env }); await writePresence(sessionId, name, squarePath, { channel, route, at, env }, false, 'user'); return sessionId; }
+export async function recordSessionDone(sessionId, name, squarePath, channel, env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); const binding = (await lookupSessionBindings(sessionId, Date.now(), env)).find((item) => item.squarePath === canonicalPath && sameName(item.name, name) && item.channel === channel); if (binding === undefined)
+    return false; const options = { channel, at: Date.now(), env }; await recordDone(sessionId, binding.name, binding.squarePath, options); await writePresence(sessionId, binding.name, binding.squarePath, options, true, 'user'); return true; }