@astrosheep/square 0.3.62 → 0.3.64

package/dist/square-core.d.ts

@@ -139,8 +139,11 @@ export declare function audienceIncludes(audience: Audience, name: string): bool
 export declare function resolveAudience(audience: Audience, candidateNames: readonly string[]): string[];
 export declare function activeListeners(state: FoldedSquareState, sender: string): string[];
 export declare function isIgnored(state: FoldedSquareState, listener: string, sender: string): boolean;
+/** The author of every landed activity, keyed by index; a reply audience derives from this. */
+export declare function activityAuthors(acts: readonly Act[]): Map<number, Participant>;
 export declare function listeningTo(state: FoldedSquareState, listener: string): string[];
 export declare function isListening(state: FoldedSquareState, listener: string, sender: string): boolean;
+export declare function actorOf(act: Act): Participant | undefined;
 export declare function fold(acts: readonly Act[]): FoldedSquareState;
 /** Replay the activity stream once to fix every say's audience at landing. */
 export declare function replayLandedAudiences(acts: readonly Act[]): LandedAudienceReplay;

package/dist/square-core.js

@@ -60,12 +60,28 @@ export function activeListeners(state, sender) {
 export function isIgnored(state, listener, sender) {
     return (state.ignored.get(nameKey(listener)) ?? []).some((target) => sameName(target, sender));
 }
-function recipientsAtLanding(before, say) {
+/** The author of every landed activity, keyed by index; a reply audience derives from this. */
+export function activityAuthors(acts) {
+    const authors = new Map();
+    for (const act of acts) {
+        const actor = actorOf(act);
+        if (actor === undefined || !('index' in act) || typeof act.index !== 'number')
+            continue;
+        authors.set(act.index, actor);
+    }
+    return authors;
+}
+function recipientsAtLanding(before, say, authors) {
     const audience = audienceOf(say);
-    const mentionTargets = resolveAudience(audience, before.participants.filter((participant) => participant.joined).map((participant) => participant.name));
+    const standing = before.participants.filter((participant) => participant.joined).map((participant) => participant.name);
+    const mentionTargets = resolveAudience(audience, standing);
+    // A reply is directed attention in its own right: it reaches the author of the
+    // replied-to activity under the same standing and ignore rules as a mention.
+    const replyAuthor = say.reply === undefined ? undefined : authors.get(say.reply);
+    const replyTargets = replyAuthor === undefined ? [] : resolveAudience({ kind: 'mentions', names: [replyAuthor] }, standing);
     const listeners = activeListeners(before, say.actor);
     const recipients = [];
-    for (const name of [...mentionTargets, ...listeners]) {
+    for (const name of [...mentionTargets, ...replyTargets, ...listeners]) {
         if (sameName(name, say.actor) || recipients.some((existing) => sameName(existing, name)))
             continue;
         if (audience.kind !== 'bell' && isIgnored(before, name, say.actor))
@@ -80,7 +96,7 @@ export function listeningTo(state, listener) {
 export function isListening(state, listener, sender) {
     return listeningTo(state, listener).some((target) => sameName(target, sender));
 }
-function actorOf(act) {
+export function actorOf(act) {
     if ('actor' in act && typeof act.actor === 'string')
         return act.actor;
     return undefined;
@@ -238,9 +254,10 @@ export function replayLandedAudiences(acts) {
     const byActivity = new Map();
     const byIndex = new Map();
     const lastJoinByKey = new Map();
+    const authors = activityAuthors(acts);
     for (const act of acts) {
         if (act.kind === 'say') {
-            const recipients = recipientsAtLanding(accumulator.state, act);
+            const recipients = recipientsAtLanding(accumulator.state, act, authors);
             byActivity.set(act, recipients);
             const index = 'index' in act ? act.index : undefined;
             if (typeof index === 'number')

package/dist/square-facade.d.ts

@@ -24,6 +24,8 @@ export interface ExpressOptions {
 export interface ExpressResult {
     readonly activity: Activity;
     readonly delivery?: DeliveryResult;
+    /** The replied-to author was not standing when the reply landed, so no notification reached them. */
+    readonly replyAuthorNotHere?: string;
 }
 export interface ListenerChangeResult {
     readonly activity: Activity | null;

package/dist/square-file-adapter.js

@@ -1,6 +1,6 @@
 export { observeSquareRevision as observeSquareChanges } from './artifact.js';
 import { hostLedgerRoot } from './host-ledger-root.js';
-import { createSquareState, createSquareSnapshot, probeSquareFile, writeSquareSnapshot, openSquareCell, createMemoryCell, } from './square-storage.js';
+import { createSquareState, createSquareSnapshot, probeSquareFile, writeSquareSnapshot, createFileCell, createMemoryCell, } from './square-storage.js';
 import { InternalSquareError, SquareError, } from './model.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 /** File-owned artifact creation for the CLI and path-backed public facade. */
@@ -51,7 +51,7 @@ export async function openSquare(squarePath, options = {}) {
 }
 export async function probeSquare(squarePath) {
     const state = await probeSquareFile(squarePath);
-    return state === undefined ? undefined : { artifact: memoryArtifact(createMemoryCell(state)), clock: Date.now, location: squarePath };
+    return state === undefined ? undefined : { artifact: createMemoryCell(state), clock: Date.now, location: squarePath, hostLedger: createHostLedgerPort({ rootPath: hostLedgerRoot(process.env) }) };
 }
 export async function buildSquare(squarePath, options) {
     validateBuildOptions(options);
@@ -77,12 +77,9 @@ export function buildMemorySquare(options) {
         hardCap: options.hardCap ?? null,
         ...(options.throttlePerMinute === undefined ? {} : { throttlePerMinute: options.throttlePerMinute }),
     }, options.markdown);
-    return { artifact: memoryArtifact(createMemoryCell(squareState)), clock: options.clock ?? Date.now, location: 'memory', hostLedger: options.hostLedger, wakeTransport: options.wakeTransport };
+    return { artifact: createMemoryCell(squareState), clock: options.clock ?? Date.now, location: 'memory', hostLedger: options.hostLedger, wakeTransport: options.wakeTransport };
 }
 /** A projection reads and validates its snapshot once; no preliminary duplicate read. */
 export function openSquareArtifact(squarePath, signal) {
-    return memoryArtifact(openSquareCell(squarePath, signal));
-}
-function memoryArtifact(cell) {
-    return { read: (signal) => cell.read(signal), transact: (fn, signal) => cell.transact(fn, signal), changed: (since, timeout, signal) => cell.changed(since, timeout, signal), close: () => cell.close() };
+    return createFileCell(squarePath, signal);
 }

package/dist/square-projections.d.ts

@@ -1,28 +1,56 @@
 import { type InboxMembership, type SquareState } from './model.js';
 import type { HostLedgerPort, SquareArtifactPort, PresentationEvidenceProjection, PresentationProjection, SessionBindingProjection } from './ports.js';
 import { deriveDeliveryModel } from './delivery.js';
-import type { WakeRoute, WakeRouteKind } from './model.js';
+import { type WakeEligibility } from './wake-eligibility.js';
 /** A fresh blocking catch owns only the notifications admitted by its filter. */
 export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
-export declare function projectSessionBindings(input: {
+/**
+ * One eligibility projection for a freshly read session inbox: a fresh catch lease owns what it
+ * admitted, and a delivered (or clipped) boundary already raised awareness for its activity, so
+ * neither belongs at the next boundary. Ordering, session scoping, suppression outcomes and
+ * ledger errors stay exactly as the boundary callers read them.
+ */
+export declare function projectBoundaryEligibility(input: {
     readonly hostLedger: HostLedgerPort;
     readonly sessionId: string;
+    readonly inbox: readonly InboxMembership[];
+}): Promise<InboxMembership[]>;
+export declare function projectSessionBindings(input: {
+    readonly hostLedger: HostLedgerPort;
+    readonly sessionId?: string;
     readonly location?: string;
     readonly now?: number;
 }): Promise<readonly SessionBindingProjection[]>;
-export declare function sessionIdsFromEnvironment(env?: NodeJS.ProcessEnv): readonly string[];
-export declare function projectLocalParticipantBinding(input: {
-    readonly hostLedger: HostLedgerPort;
-    readonly location: string;
-    readonly participant: string;
-    readonly sessionIds: readonly string[];
-    readonly now?: number;
-}): Promise<SessionBindingProjection | undefined>;
 export declare function projectPresentation(input: {
     readonly artifact: SquareArtifactPort;
     readonly binding: SessionBindingProjection;
     readonly now?: number;
 }): Promise<PresentationProjection>;
+export interface NativePendingPreview {
+    readonly payload: string;
+    readonly clipped: boolean;
+}
+/** The one native pending preview. `epoch` matches exactly, and each harness pins its own address entry. */
+export type NativePendingPreviewInput = {
+    readonly location: string;
+    readonly sessionId: string;
+    readonly participant: string;
+    readonly actIndex: number;
+    readonly epoch?: number;
+    readonly cancelledThrough?: number;
+    readonly now: number;
+} & ({
+    readonly routeKind: 'claude-native';
+    readonly address: {
+        readonly endpoint: string;
+    };
+} | {
+    readonly routeKind: 'opencode-server';
+    readonly address: {
+        readonly sessionId: string;
+    };
+});
+export declare function nativePendingPreview(state: SquareState, input: NativePendingPreviewInput): NativePendingPreview | undefined;
 export declare function projectPresentationEvidence(input: {
     readonly hostLedger: HostLedgerPort;
     readonly location?: string;
@@ -33,44 +61,11 @@ export declare function projectPresentationEvidence(input: {
 }): Promise<readonly PresentationEvidenceProjection[]>;
 /** Successful boundary output, including a clipped preview, suppresses awareness wake. */
 export declare function presentationSuppressesWake(evidence: readonly Pick<PresentationEvidenceProjection, 'outcome'>[]): boolean;
-/** The most recently published session owns wake eligibility for its participant. */
-export declare function currentSessionBindings<T extends {
-    readonly participant: string;
-    readonly updatedAt?: number;
-}>(bindings: readonly T[]): T[];
-export interface WakeAttempt {
-    readonly at: number;
-    readonly attention: {
-        readonly squarePath: string;
-        readonly actIndex: number;
-        readonly recipient: string;
-    };
-    readonly routeKind: WakeRouteKind;
-    readonly outcome: 'accepted' | 'unknown' | 'failed';
-    readonly signature?: string;
-    readonly attemptN: number;
-    readonly session?: string;
-    readonly message?: string;
-    readonly diagnostic?: unknown;
-}
-export declare function terminalWakeEvidence(attempts: readonly WakeAttempt[]): WakeAttempt | undefined;
-export declare function isWakeRouteAttemptable(route: Pick<WakeRoute, 'kind' | 'updatedAt'>, attempts: readonly WakeAttempt[]): boolean;
-export declare function hasAttemptableWakeRoute(routes: readonly Pick<WakeRoute, 'kind' | 'updatedAt'>[], attempts: readonly WakeAttempt[]): boolean;
-export interface WakeEvidence {
-    readonly delivered: boolean;
-    readonly presented: boolean;
-    readonly attempts: readonly WakeAttempt[];
-    readonly terminal?: WakeAttempt;
-    readonly attemptableRoutes: readonly WakeRoute[];
-}
-export interface WakeEvidenceProjection {
-    evidence(recipient: string, actIndex: number): WakeEvidence;
-}
+/** Read primary evidence once; wake behavior belongs to the pure eligibility projection. */
 export declare function projectWakeEvidenceFromState(input: {
     readonly location: string;
     readonly state: SquareState;
     readonly hostLedger: HostLedgerPort;
     readonly now: number;
     readonly delivery?: ReturnType<typeof deriveDeliveryModel>;
-}): Promise<WakeEvidenceProjection>;
-export declare function wakeIsEligible(evidence: WakeEvidence): boolean;
+}): Promise<WakeEligibility>;

package/dist/square-projections.js

@@ -1,8 +1,10 @@
-import { formatActivityId, parseActivityId } from './square-core.js';
+import { formatActivityId } from './square-core.js';
 import { nameKey } from './model.js';
 import { deriveDeliveryModel, leaseOwnsNotification } from './delivery.js';
 import { freshWatchLease } from './runtime.js';
-import { canonicalRouteLocation } from './routes.js';
+import { attentionBodyIsClipped, renderAttentionPreview } from './attention-presentation.js';
+import { canonicalPath } from './canonical-path.js';
+import { projectWakeEligibility } from './wake-eligibility.js';
 /** A fresh blocking catch owns only the notifications admitted by its filter. */
 export function pendingAtBoundary(inbox) {
     return inbox.map((membership) => {
@@ -12,37 +14,33 @@ export function pendingAtBoundary(inbox) {
         return { ...membership, notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })) };
     }).filter((membership) => membership.notifications.length > 0);
 }
-function bindingProjection(record) {
-    return {
+/**
+ * One eligibility projection for a freshly read session inbox: a fresh catch lease owns what it
+ * admitted, and a delivered (or clipped) boundary already raised awareness for its activity, so
+ * neither belongs at the next boundary. Ordering, session scoping, suppression outcomes and
+ * ledger errors stay exactly as the boundary callers read them.
+ */
+export async function projectBoundaryEligibility(input) {
+    const pending = [];
+    for (const membership of pendingAtBoundary([...input.inbox])) {
+        const evidence = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: membership.squarePath, participant: membership.name, sessionId: input.sessionId });
+        const notifications = membership.notifications.filter((notification) => !presentationSuppressesWake(evidence.filter((row) => row.activity === formatActivityId(notification.actIndex))));
+        if (notifications.length > 0)
+            pending.push({ ...membership, notifications });
+    }
+    return pending;
+}
+export async function projectSessionBindings(input) {
+    const rows = await input.hostLedger.listPresence({ location: input.location, session: input.sessionId, now: input.now });
+    return rows.map((record) => ({
         location: record.location,
         participant: record.participant,
         sessionId: record.session,
         channel: record.channel,
-        ...(record.route === undefined ? {} : {
-            route: {
-                location: record.location,
-                participant: record.participant,
-                sessionId: record.session,
-                channel: record.channel,
-                kind: record.route.kind,
-                address: { ...record.route.address },
-                updatedAt: record.updatedAt ?? 0,
-            },
-        }),
+        ...(record.epoch === undefined ? {} : { epoch: record.epoch }),
+        ...(record.cancelledThrough === undefined ? {} : { cancelledThrough: record.cancelledThrough }),
         updatedAt: record.updatedAt ?? 0,
-    };
-}
-export async function projectSessionBindings(input) {
-    const rows = await input.hostLedger.listPresence({ location: input.location, session: input.sessionId, now: input.now });
-    return rows.map(bindingProjection);
-}
-export function sessionIdsFromEnvironment(env = process.env) {
-    return [env.CLAUDE_CODE_SESSION_ID, env.CODEX_THREAD_ID, env.OPENCODE_SESSION_ID, env.PI_SESSION_ID, env.PASEO_AGENT_ID]
-        .map((value) => value?.trim()).filter((value) => Boolean(value));
-}
-export async function projectLocalParticipantBinding(input) {
-    const bindings = (await Promise.all(input.sessionIds.map((sessionId) => projectSessionBindings({ hostLedger: input.hostLedger, location: input.location, sessionId, now: input.now })))).flat();
-    return bindings.find((binding) => binding.participant.toLocaleLowerCase() === input.participant.toLocaleLowerCase());
+    }));
 }
 export async function projectPresentation(input) {
     const { state } = await input.artifact.read();
@@ -55,6 +53,18 @@ export async function projectPresentation(input) {
     const lease = freshWatchLease(state, known, input.now ?? Date.now());
     return { binding, joined: true, notifications, ...(lease === undefined ? {} : { catchLease: lease }) };
 }
+export function nativePendingPreview(state, input) {
+    const route = state.routes?.find((candidate) => candidate.kind === input.routeKind && candidate.sessionId === input.sessionId
+        && candidate.epoch === input.epoch && nameKey(candidate.participant) === nameKey(input.participant)
+        && (input.routeKind === 'claude-native' ? candidate.address.endpoint === input.address.endpoint : candidate.address.sessionId === input.address.sessionId));
+    if (!route || input.actIndex <= (input.cancelledThrough ?? -1))
+        return undefined;
+    const notification = deriveDeliveryModel(state).pendingFor(input.participant).find((entry) => entry.item.index === input.actIndex);
+    const lease = freshWatchLease(state, input.participant, input.now);
+    if (!notification || (lease !== undefined && leaseOwnsNotification(lease, { ...notification.item, recipient: input.participant, route: notification.route })))
+        return undefined;
+    return { payload: renderAttentionPreview({ squarePath: input.location, recipient: input.participant, actIndex: input.actIndex, actor: notification.item.actor, route: notification.route, body: notification.item.body }), clipped: attentionBodyIsClipped(notification.item.body) };
+}
 export async function projectPresentationEvidence(input) {
     const rows = await input.hostLedger.listEvidence({ kind: 'presentation', location: input.location, participant: input.participant, session: input.sessionId, activity: input.activity, now: input.now });
     return rows.map((row) => ({ location: row.location, participant: row.participant, sessionId: row.session, activity: row.activity, outcome: row.outcome, ...(row.at === undefined ? {} : { at: row.at }) }));
@@ -63,52 +73,12 @@ export async function projectPresentationEvidence(input) {
 export function presentationSuppressesWake(evidence) {
     return evidence.some((row) => row.outcome === 'clipped' || row.outcome === 'presented');
 }
-/** The most recently published session owns wake eligibility for its participant. */
-export function currentSessionBindings(bindings) {
-    const latest = new Map();
-    for (const binding of bindings) {
-        const participant = nameKey(binding.participant);
-        latest.set(participant, Math.max(latest.get(participant) ?? Number.NEGATIVE_INFINITY, binding.updatedAt ?? 0));
-    }
-    return bindings.filter((binding) => (binding.updatedAt ?? 0) === latest.get(nameKey(binding.participant)));
-}
-export function terminalWakeEvidence(attempts) { return attempts.findLast((attempt) => attempt.outcome === 'accepted'); }
-export function isWakeRouteAttemptable(route, attempts) {
-    if (terminalWakeEvidence(attempts) !== undefined)
-        return false;
-    if (attempts.some((attempt) => attempt.routeKind === route.kind && attempt.outcome === 'unknown'))
-        return false;
-    return true;
-}
-export function hasAttemptableWakeRoute(routes, attempts) { return routes.some((route) => isWakeRouteAttemptable(route, attempts)); }
+/** Read primary evidence once; wake behavior belongs to the pure eligibility projection. */
 export async function projectWakeEvidenceFromState(input) {
-    const canonicalLocation = await canonicalRouteLocation(input.location);
+    const canonicalLocation = await canonicalPath(input.location);
     const delivery = input.delivery ?? deriveDeliveryModel(input.state);
-    const bindings = (input.state.routes ?? [])
-        .filter((route) => route.location === canonicalLocation || route.location === input.location)
-        .map((route) => ({ location: route.location, participant: route.participant, sessionId: route.sessionId, channel: route.channel, route: { ...route, address: { ...route.address } }, updatedAt: route.updatedAt }));
+    const owners = await input.hostLedger.listPresence({ location: canonicalLocation, now: input.now });
     const wakeRecords = await input.hostLedger.listEvidence({ location: canonicalLocation, kind: 'wake', now: input.now });
-    const attemptsByBinding = new Map();
-    for (const record of wakeRecords) {
-        const actIndex = parseActivityId(record.activity);
-        if (actIndex === undefined || record.routeKind === undefined || typeof record.attemptN !== 'number')
-            continue;
-        const attempt = { attention: { squarePath: record.location, recipient: record.participant, actIndex }, outcome: record.outcome, at: record.at ?? input.now, routeKind: record.routeKind, 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 }) };
-        const key = JSON.stringify([nameKey(record.participant), actIndex, record.session]);
-        const existing = attemptsByBinding.get(key) ?? [];
-        existing.push(attempt);
-        attemptsByBinding.set(key, existing);
-    }
-    const presentedRows = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: canonicalLocation, now: input.now });
-    return {
-        evidence(recipient, actIndex) {
-            const recipientBindings = currentSessionBindings(bindings.filter((binding) => nameKey(binding.participant) === nameKey(recipient)));
-            const routes = recipientBindings.flatMap((binding) => binding.route === undefined ? [] : [binding.route]);
-            const attempts = recipientBindings.flatMap((binding) => attemptsByBinding.get(JSON.stringify([nameKey(recipient), actIndex, binding.sessionId])) ?? []);
-            const terminal = terminalWakeEvidence(attempts);
-            const presented = presentedRows.some((row) => row.activity === formatActivityId(actIndex) && row.participant.toLocaleLowerCase() === recipient.toLocaleLowerCase() && recipientBindings.some((binding) => binding.sessionId === row.sessionId) && presentationSuppressesWake([row]));
-            return { delivered: delivery.isSeen(recipient, actIndex), presented, attempts, ...(terminal === undefined ? {} : { terminal }), attemptableRoutes: terminal === undefined ? routes.filter((route) => isWakeRouteAttemptable(route, attempts)) : [] };
-        },
-    };
+    const presentations = await projectPresentationEvidence({ hostLedger: input.hostLedger, location: canonicalLocation, now: input.now });
+    return projectWakeEligibility({ state: input.state, location: canonicalLocation, owners, wakeRecords, presentations, now: input.now, delivery });
 }
-export function wakeIsEligible(evidence) { return !evidence.delivered && !evidence.presented && evidence.terminal === undefined && evidence.attemptableRoutes.length > 0; }

package/dist/square-state.js

@@ -25,9 +25,6 @@ function isNonblankString(value) {
 function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
-function validateObservation(value) {
-    return isObject(value) && hasExactKeys(value, ['state', 'at']) && value.state === 'seen' && isFiniteNumber(value.at);
-}
 function validateWatchLease(value) {
     if (!isObject(value) || !hasExactKeys(value, ['leaseId', 'heartbeatAt', 'expiresAt'], ['filter'])
         || !isNonblankString(value.leaseId) || !isFiniteNumber(value.heartbeatAt)
@@ -46,7 +43,7 @@ function validateRuntime(value) {
     return isObject(value) && hasExactKeys(value, ['nextActIndex', 'observations', 'leases'])
         && isNonNegativeInteger(value.nextActIndex)
         && validateRecord(value.observations, (candidate) => isObject(candidate)
-            && Object.entries(candidate).every(([id, observation]) => parseActivityId(id) !== undefined && validateObservation(observation)))
+            && Object.entries(candidate).every(([id, observation]) => parseActivityId(id) !== undefined && isObject(observation) && hasExactKeys(observation, ['state', 'at']) && observation.state === 'seen' && isFiniteNumber(observation.at)))
         && validateRecord(value.leases, validateWatchLease);
 }
 function validateAssignedRuntimeReferences(runtime) {

package/dist/square-storage.d.ts

@@ -1,17 +1,14 @@
 import { createSquareState, diagnoseSquareFile as diagnoseArtifactFile } from './artifact.js';
 import type { SquareState } from './model.js';
-import type { StateCell } from './state-cell.js';
+import type { SquareArtifactPort } from './ports.js';
 export { createSquareState };
-export declare function readSquareFile(squarePath: string): Promise<SquareState>;
 export declare function probeSquareFile(squarePath: string): Promise<SquareState | undefined>;
 export declare function diagnoseSquareFile(squarePath: string): ReturnType<typeof diagnoseArtifactFile>;
 /** Test-helper snapshot replacement backed by one SQLite artifact. */
 export declare function writeSquareSnapshot(squarePath: string, squareState: SquareState): Promise<void>;
 /** Race-safe non-force creation for the file adapter. */
 export declare function createSquareSnapshot(squarePath: string, squareState: SquareState): Promise<boolean>;
-/** In-process cell for fast behavior tests and embedded consumers. */
-export declare function createMemoryCell(initial: SquareState): StateCell;
-/** SQLite-backed cell. Revisions are read from the authoritative database, not file metadata. */
-export declare function createFileCell(squarePath: string, externalSignal?: AbortSignal): StateCell;
-/** Consumer-facing file cell factory; keeps SQLite framing behind this module. */
-export declare function openSquareCell(squarePath: string, signal?: AbortSignal): StateCell;
+/** In-process artifact for fast behavior tests and embedded consumers. */
+export declare function createMemoryCell(initial: SquareState): SquareArtifactPort;
+/** SQLite-backed artifact. Revisions are read from the authoritative database, not file metadata. */
+export declare function createFileCell(squarePath: string, externalSignal?: AbortSignal): SquareArtifactPort;

package/dist/square-storage.js

@@ -1,23 +1,7 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-import { createSquareFile, createSquareState, diagnoseSquareFile as diagnoseArtifactFile, loadSquare, probeSquare, observeSquareRevision, readSquareSnapshot, transactSquareSnapshot, writeSquareFile, } from './artifact.js';
+import { createSquareFile, createSquareState, diagnoseSquareFile as diagnoseArtifactFile, probeSquare, observeSquareRevision, readSquareSnapshot, transactSquareSnapshot, writeSquareFile, } from './artifact.js';
+import { canonicalPath } from './canonical-path.js';
 export { createSquareState };
-async function canonicalPath(squarePath) {
-    const absolute = path.resolve(squarePath);
-    try {
-        return await fs.promises.realpath(absolute);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-        const parent = await fs.promises.realpath(path.dirname(absolute)).catch(() => path.dirname(absolute));
-        return path.join(parent, path.basename(absolute));
-    }
-}
-export async function readSquareFile(squarePath) {
-    return loadSquare(await canonicalPath(squarePath));
-}
 export async function probeSquareFile(squarePath) {
     if (!squarePath.endsWith('.square'))
         return undefined;
@@ -39,7 +23,7 @@ function cloneState(squareState) {
 }
 function assertCellOpen(closed) {
     if (closed)
-        throw new Error('StateCell is closed');
+        throw new Error('Square artifact is closed');
 }
 function isThenable(value) {
     return (typeof value === 'object' || typeof value === 'function') && value !== null
@@ -48,7 +32,7 @@ function isThenable(value) {
 function discardThenable(value) {
     void Promise.resolve(value).catch(() => undefined);
 }
-/** In-process cell for fast behavior tests and embedded consumers. */
+/** In-process artifact for fast behavior tests and embedded consumers. */
 export function createMemoryCell(initial) {
     let state = cloneState(initial);
     let version = 0;
@@ -69,11 +53,11 @@ export function createMemoryCell(initial) {
         transact(fn, signal) {
             assertCellOpen(closed);
             if (signal?.aborted)
-                throw signal.reason ?? new Error('StateCell operation aborted');
+                throw signal.reason ?? new Error('Square artifact operation aborted');
             const operation = tail.then(() => {
                 assertCellOpen(closed);
                 if (signal?.aborted)
-                    throw signal.reason ?? new Error('StateCell operation aborted');
+                    throw signal.reason ?? new Error('Square artifact operation aborted');
                 const current = cloneState(state);
                 const outcome = fn(current, version);
                 if (isThenable(outcome)) {
@@ -96,27 +80,27 @@ export function createMemoryCell(initial) {
         async read(signal) {
             assertCellOpen(closed);
             if (signal?.aborted)
-                throw signal.reason ?? new Error('StateCell operation aborted');
+                throw signal.reason ?? new Error('Square artifact operation aborted');
             await tail;
             assertCellOpen(closed);
             if (signal?.aborted)
-                throw signal.reason ?? new Error('StateCell operation aborted');
+                throw signal.reason ?? new Error('Square artifact operation aborted');
             return { state: cloneState(state), version };
         },
         changed(sinceVersion, timeoutMs, signal) {
             assertCellOpen(closed);
             if (signal?.aborted)
-                return Promise.reject(signal.reason ?? new Error("StateCell operation aborted"));
+                return Promise.reject(signal.reason ?? new Error("Square artifact operation aborted"));
             if (version > sinceVersion)
                 return Promise.resolve(true);
             if (timeoutMs <= 0)
                 return Promise.resolve(false);
             return new Promise((resolve, reject) => {
                 if (signal?.aborted) {
-                    reject(signal.reason ?? new Error("StateCell operation aborted"));
+                    reject(signal.reason ?? new Error("Square artifact operation aborted"));
                     return;
                 }
-                const abort = () => { waiters.delete(waiter); clearTimeout(waiter.timer); signal?.removeEventListener("abort", abort); reject(signal?.reason ?? new Error("StateCell operation aborted")); };
+                const abort = () => { waiters.delete(waiter); clearTimeout(waiter.timer); signal?.removeEventListener("abort", abort); reject(signal?.reason ?? new Error("Square artifact operation aborted")); };
                 const waiter = {
                     since: sinceVersion,
                     resolve,
@@ -142,7 +126,7 @@ export function createMemoryCell(initial) {
         },
     };
 }
-/** SQLite-backed cell. Revisions are read from the authoritative database, not file metadata. */
+/** SQLite-backed artifact. Revisions are read from the authoritative database, not file metadata. */
 export function createFileCell(squarePath, externalSignal) {
     let closed = false;
     let storage;
@@ -152,9 +136,6 @@ export function createFileCell(squarePath, externalSignal) {
         storage ??= canonicalPath(squarePath);
         return storage;
     }
-    function abortError() {
-        return new Error('StateCell is closed');
-    }
     /** Close wins over every operation; a per-call deadline bounds busy retries alongside it. */
     function operationSignal(signal) {
         if (signal === undefined && externalSignal === undefined)
@@ -200,12 +181,8 @@ export function createFileCell(squarePath, externalSignal) {
             if (closed)
                 return;
             closed = true;
-            cancel.abort(abortError());
+            cancel.abort(new Error('Square artifact is closed'));
             await tail;
         },
     };
 }
-/** Consumer-facing file cell factory; keeps SQLite framing behind this module. */
-export function openSquareCell(squarePath, signal) {
-    return createFileCell(squarePath, signal);
-}

package/dist/square-wiring.d.ts

@@ -31,8 +31,3 @@ export declare class Square {
     endOwnedSession(name: string, sessionId: string, expectedEpoch?: number): Promise<ExpressResult | null>;
     retireEndedSessionRoutes(sessionId: string): Promise<void>;
 }
-export declare function markBoundarySeen(squarePath: string, name: string, actIndexes: readonly number[], at?: number): Promise<void>;
-export declare function openParticipant(input: SquareAtInput, name: string): Promise<{
-    readonly participant: Participant;
-    close(): Promise<void>;
-}>;

package/dist/square-wiring.js

@@ -1,10 +1,10 @@
 import { closeOpenSquare } from './open-square.js';
 import { buildMemorySquare, buildSquare, openSquare } from './square-file-adapter.js';
 import { catchUp, done, endOwnedSession, express, hold, ignore, implicitJoin, join, takeover, listen, listening, resume, retireEndedSessionRoutes, } from './square-actions.js';
-import { markBoundarySeen as recordBoundarySeen } from './presence.js';
-import { history, participantHistory, participants, resolveParticipant, snapshot } from './views.js';
+import { history, participantHistory, participants, snapshot } from './views.js';
 import { currentParticipant } from './views.js';
 import { projectSessionBindings } from './square-projections.js';
+import { sessionIdsFromEnvironment } from './participant-identity.js';
 class ParticipantHandle {
     name;
     square;
@@ -90,8 +90,7 @@ export class Square {
     async recognize(env) {
         if (this.square.hostLedger === undefined)
             return null;
-        const sessions = [env.CLAUDE_CODE_SESSION_ID, env.CODEX_THREAD_ID, env.OPENCODE_SESSION_ID, env.PI_SESSION_ID, env.PASEO_AGENT_ID]
-            .map((value) => value?.trim()).filter((value) => Boolean(value));
+        const sessions = sessionIdsFromEnvironment(env);
         if (sessions.length === 0)
             return null;
         const candidates = (await Promise.all(sessions.map((sessionId) => projectSessionBindings({
@@ -108,20 +107,3 @@ export class Square {
     endOwnedSession(name, sessionId, expectedEpoch) { return endOwnedSession(this.context, name, sessionId, expectedEpoch); }
     retireEndedSessionRoutes(sessionId) { return retireEndedSessionRoutes(this.context, sessionId); }
 }
-export function markBoundarySeen(squarePath, name, actIndexes, at) {
-    return recordBoundarySeen(squarePath, name, actIndexes, at);
-}
-export async function openParticipant(input, name) {
-    const square = await openSquare(input.path, input);
-    try {
-        const known = await resolveParticipant(square, name);
-        return {
-            participant: new ParticipantHandle(known.name, square, square),
-            close: () => closeOpenSquare(square),
-        };
-    }
-    catch (error) {
-        await closeOpenSquare(square);
-        throw error;
-    }
-}

package/dist/stream.js

@@ -5,10 +5,6 @@ import { quoteShell } from './presentation.js';
 import { openSquare, observeSquareChanges } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { streamProjection, streamTailProjection } from './views.js';
-async function writeNdjson(value) {
-    if (!process.stdout.write(`${JSON.stringify(value)}\n`))
-        await once(process.stdout, 'drain');
-}
 /** Machine-readable tailing stays available; interactive terminal rendering was retired. */
 export async function cmdStreamNdjson(squarePath, recipient, start = { kind: 'tail', last: 10 }) {
     if (!fs.existsSync(squarePath)) {
@@ -31,8 +27,10 @@ export async function cmdStreamNdjson(squarePath, recipient, start = { kind: 'ta
                         ? await streamProjection(square, cursor, recipient)
                         : await streamTailProjection(square, initial.last, recipient);
                     for (const item of projection.activities) {
-                        await writeNdjson({ seq: item.activity.index, square: squarePath, ...item.activity,
-                            ...(item.route === undefined ? {} : { route: item.route }) });
+                        const line = { seq: item.activity.index, square: squarePath, ...item.activity,
+                            ...(item.route === undefined ? {} : { route: item.route }) };
+                        if (!process.stdout.write(`${JSON.stringify(line)}\n`))
+                            await once(process.stdout, 'drain');
                     }
                     cursor = projection.cursor;
                     initial = undefined;

package/dist/time.js

@@ -1,12 +1,6 @@
 function pad(value, length = 2) {
     return String(value).padStart(length, '0');
 }
-function formatOffset(date) {
-    const offsetMinutes = -date.getTimezoneOffset();
-    const sign = offsetMinutes >= 0 ? '+' : '-';
-    const abs = Math.abs(offsetMinutes);
-    return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
-}
 export function formatTimestamp(at) {
     const date = new Date(at);
     const time = date.getMilliseconds() !== 0
@@ -14,10 +8,11 @@ export function formatTimestamp(at) {
         : date.getSeconds() !== 0
             ? `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
             : `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+    const offsetMinutes = -date.getTimezoneOffset();
     return [
         `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`,
         time,
-        formatOffset(date),
+        `${offsetMinutes >= 0 ? '+' : '-'}${pad(Math.floor(Math.abs(offsetMinutes) / 60))}:${pad(Math.abs(offsetMinutes) % 60)}`,
     ].join(' ');
 }
 export function formatDuration(ms) {