@astrosheep/square 0.3.62 → 0.3.64

package/dist/paseo-timeline.js

@@ -1,5 +1,5 @@
 import { setTimeout as sleep } from 'node:timers/promises';
-import { connectPaseoDaemon } from './paseo-connection.js';
+import { daemonCredential, openPaseoClient, resolvePaseoDaemon, } from './packages/agent-delivery/src/paseo-native.js';
 async function waitSnapshots(agentId, read, opts) {
     const initial = await read(agentId);
     if (initial.agentStatus === 'idle')
@@ -25,19 +25,6 @@ async function waitSnapshots(agentId, read, opts) {
     }
     return false;
 }
-function snapshotFromPayload(payload) {
-    const tools = new Map();
-    for (const entry of payload.entries ?? []) {
-        const item = entry.item;
-        if (item.type === 'tool_call' && ['running', 'completed', 'failed'].includes(item.status)) {
-            tools.set(item.callId, item.status);
-        }
-    }
-    return {
-        agentStatus: payload.agent?.status ?? 'unknown',
-        toolCalls: [...tools].map(([callId, status]) => ({ callId, status })),
-    };
-}
 export async function waitForPaseoToolBoundary(agentId, opts = {}) {
     if (opts.readSnapshot !== undefined) {
         try {
@@ -47,15 +34,32 @@ export async function waitForPaseoToolBoundary(agentId, opts = {}) {
             return false;
         }
     }
+    const target = resolvePaseoDaemon(undefined);
+    if (target === undefined)
+        return false;
     let client;
     try {
-        client = await connectPaseoDaemon();
-        return await waitSnapshots(agentId, async (id) => snapshotFromPayload(await client.fetchAgentTimeline(id, {
-            direction: 'tail',
-            limit: 200,
-            projection: 'projected',
-            timeout: 3_000,
-        })), opts);
+        client = await openPaseoClient(target, daemonCredential({ endpointPassword: target.password }), 3_000);
+        return await waitSnapshots(agentId, async (id) => {
+            const payload = await client.fetchAgentTimeline(id, {
+                direction: 'tail',
+                limit: 200,
+                projection: 'projected',
+                timeout: 3_000,
+            });
+            const tools = new Map();
+            for (const entry of payload.entries ?? []) {
+                const { type, callId, status } = entry.item;
+                if (type === 'tool_call' && callId !== undefined &&
+                    (status === 'running' || status === 'completed' || status === 'failed')) {
+                    tools.set(callId, status);
+                }
+            }
+            return {
+                agentStatus: payload.agent?.status ?? 'unknown',
+                toolCalls: [...tools].map(([callId, status]) => ({ callId, status })),
+            };
+        }, opts);
     }
     catch {
         return false;

package/dist/paseo.d.ts

@@ -1,6 +1,6 @@
 /** Optional Paseo integration. Importing this entry requires the Paseo peer dependencies. */
 export { PaseoAdapter } from './paseo-delivery.js';
-export { PaseoWakeSendError, sendPaseoWake } from './wake-sink.js';
-export { connectPaseoDaemon, paseoDaemonHosts, resolvePaseoDaemonTarget, } from './paseo-connection.js';
+export { paseoWakeMessageId, sendPaseoWake } from './wake-sink.js';
+export type { PaseoWakeRequest } from './wake-sink.js';
 export { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
 export type { PaseoAgent } from './paseo-state.js';

package/dist/paseo.js

@@ -1,5 +1,4 @@
 /** Optional Paseo integration. Importing this entry requires the Paseo peer dependencies. */
 export { PaseoAdapter } from './paseo-delivery.js';
-export { PaseoWakeSendError, sendPaseoWake } from './wake-sink.js';
-export { connectPaseoDaemon, paseoDaemonHosts, resolvePaseoDaemonTarget, } from './paseo-connection.js';
+export { paseoWakeMessageId, sendPaseoWake } from './wake-sink.js';
 export { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';

package/dist/ports.d.ts

@@ -1,5 +1,4 @@
 import type { InboxNotification, SquareState, StoredAct, WakeRoute, WatchLease } from './model.js';
-import type { PlannedNotification } from './delivery.js';
 export type { ClaimResult, EvidenceClaim, EvidenceRelease, EvidenceGc, EvidenceLookup, EvidenceRecord, HostLedgerPort, PresenceKey, PresenceLookup, PresenceRecord, PresenceClaimResult, PresenceChannel, PresenceResult, } from './host-ledger.js';
 import type { HostLedgerPort } from './host-ledger.js';
 /** Atomic artifact access. Never exposes framing, compression, locks, or storage schema. */
@@ -23,14 +22,15 @@ export interface WakeTransportPort {
         readonly diagnostic?: string;
     }>;
     attempt(request: WakeRequest, timeoutMs: number, beforeSend?: () => Promise<boolean>): Promise<WakeOutcome>;
-    /** Optional route retirement supplied by the concrete executor adapter. */
-    invalidate?(request: WakeRequest): Promise<void>;
 }
 export interface WakeRequest {
     readonly location: string;
     readonly participant: string;
     readonly activity: string;
     readonly actor: string;
+    /** Wake attempt token, also the opaque native correlation. */
+    readonly claimToken?: string;
+    readonly attemptN?: number;
     readonly route: WakeRoute;
 }
 /** Executor-neutral presentation capability; intentionally separate from wake transport. */
@@ -39,11 +39,12 @@ export interface PresentationSinkPort {
 }
 /** Stable projection of a host binding; storage rows never cross this boundary. */
 export interface SessionBindingProjection {
+    readonly epoch?: number;
+    readonly cancelledThrough?: number;
     readonly location: string;
     readonly participant: string;
     readonly sessionId: string;
     readonly channel: import('./host-ledger.js').PresenceChannel;
-    readonly route?: WakeRoute;
     readonly updatedAt: number;
 }
 /** Pending boundary presentation projected for one bound session. */
@@ -85,22 +86,6 @@ export type WakeOutcome = {
     readonly diagnostic?: unknown;
     readonly attemptN?: number;
 };
-export interface SquareObservation {
-    readonly location?: string;
-    readonly version: number;
-    readonly state: SquareState;
-    readonly pending: readonly {
-        readonly recipient: string;
-        readonly notifications: readonly PlannedNotification[];
-    }[];
-    readonly bindings: readonly SessionBindingProjection[];
-}
-export interface ObserveSquareInput {
-    readonly artifact: SquareArtifactPort;
-    readonly hostLedger?: HostLedgerPort;
-    readonly location?: string;
-    readonly now?: number;
-}
 export interface DeliveryResult {
     readonly attempted: number;
     readonly accepted: number;
@@ -135,4 +120,6 @@ export interface PresentPendingInput {
     readonly signal?: AbortSignal;
     /** Boundary previews that were clipped remain pending for a later full presentation. */
     readonly markSeen?: boolean;
+    /** Receiver-specific fences checked inside the artifact observation transaction. */
+    readonly current?: (state: SquareState) => boolean;
 }

package/dist/presentation-operations.js

@@ -15,7 +15,7 @@ export async function presentPending(input) {
     }
     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))
+    if (input.current?.(before.state) === false || item === undefined || delivery.isSeen(input.participant, index) || !delivery.pendingFor(input.participant).some((notification) => notification.item.index === index))
         return { presented: false };
     let claimToken;
     if (input.hostLedger !== undefined && input.session !== undefined) {
@@ -31,7 +31,7 @@ export async function presentPending(input) {
             await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken }).catch(() => undefined);
             return { presented: false };
         }
-        if (deriveDeliveryModel(current.state).isSeen(input.participant, index)) {
+        if (input.current?.(current.state) === false || 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', claimToken }).catch(() => undefined);
             return { presented: false };
         }
@@ -45,8 +45,20 @@ export async function presentPending(input) {
     }
     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 }; }, input.signal);
+    const committed = await input.artifact.transact((state) => {
+        const current = deriveDeliveryModel(state);
+        if (input.current?.(state) === false || current.isSeen(input.participant, index) || !current.pendingFor(input.participant).some((notification) => notification.item.index === index))
+            return { result: false };
+        if (input.markSeen === false)
+            return { result: true };
+        const changed = recordObservation(state, input.participant, index, 'seen', input.now ?? Date.now());
+        return changed ? { state, result: true } : { result: false };
+    }, input.signal);
+    if (!committed) {
+        if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== undefined)
+            await input.hostLedger.releaseEvidence({ location: input.location, participant: input.participant, session: input.session, activity: formatActivityId(index), kind: 'presentation', claimToken });
+        return { presented: false };
+    }
     if (input.hostLedger !== undefined && input.session !== undefined && claimToken !== 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' } : {}), claimToken });
     return { presented: true, activity: item };

package/dist/presentation.d.ts

@@ -24,7 +24,6 @@ interface ActivityBlockedOptions extends ParticipantOutputOptions {
     retryCommand: string;
     forceCommand: string;
     activitySummaries: UnreadActivitySummary[];
-    unreadRoomChanges: RoomChangeAct[];
     draftPath?: string;
 }
 interface ExpressWaitingOptions {
@@ -37,6 +36,7 @@ interface ExpressNoWaitOptions extends ParticipantOutputOptions {
     reason: 'throttled' | 'held';
     retryCommand: string;
     delayMs?: number;
+    holder?: string;
     holdReason?: string;
     draftPath?: string;
 }
@@ -48,6 +48,8 @@ interface WatchStatusOptions extends ParticipantOutputOptions {
         now: number;
     };
     showCatchHint?: boolean;
+    ownActivityCount?: number;
+    hardCap?: number | null;
 }
 export declare function displayPath(squarePath: string, cwd?: string): string;
 export declare function withPathOutput(squarePath: string, body?: string, opts?: HeaderOptions): string;
@@ -71,14 +73,27 @@ export declare function truncateChars(body: string, maxChars: number): {
     remaining: number;
 };
 export declare function truncateExternalDiagnostic(diagnostic: string): string;
-export declare function previewActivityBody(body: string): string;
 export declare function renderRoomChangeText(event: RoomChangeAct): string;
+interface RenderedEvent {
+    text: string;
+    /** The rendered body was cut short by `preview`. */
+    bodyClipped: boolean;
+}
 export declare function renderEventCli(event: StoredAct, opts?: {
     now?: number;
     preview?: number;
     actNumber?: number;
     mention?: string;
 }): string;
+export declare function renderAmbientEventFacts(event: StoredAct, viewer: string, opts?: {
+    now?: number;
+    preview?: number;
+    presencePreview?: number;
+    actNumber?: number;
+    mention?: string;
+    squareState?: SquareState;
+    perception?: Perception;
+}): RenderedEvent;
 export declare function renderAmbientEvent(event: StoredAct, viewer: string, opts?: {
     now?: number;
     preview?: number;
@@ -88,7 +103,7 @@ export declare function renderAmbientEvent(event: StoredAct, viewer: string, opt
     squareState?: SquareState;
     perception?: Perception;
 }): string;
-export declare function renderPendingFeed(history: StoredAct[], publicItems: PublicAct[], roomChanges: RoomChangeAct[], viewer: string | undefined, squareState: SquareState): string;
+export declare function renderPendingFeed(history: StoredAct[], publicItems: PublicAct[], viewer: string | undefined, squareState: SquareState): string;
 export declare function renderActivityBlocked(opts: ActivityBlockedOptions): string;
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export declare function renderActivityUncertain(opts: ParticipantOutputOptions & {
@@ -98,9 +113,7 @@ export declare function renderActivityUncertain(opts: ParticipantOutputOptions &
 }): string;
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
 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, 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;
@@ -110,13 +123,9 @@ export declare function renderWatchReplaced(_opts: ParticipantOutputOptions): st
 export declare function renderWatchStatus(opts: WatchStatusOptions): string;
 export declare function renderDoctorClean(): string;
 export declare function renderDoctorUnfixable(reason: string): string;
-export declare function renderWatchOutput(history: StoredAct[], publicItems: PublicAct[], roomChanges: RoomChangeAct[], opts: {
-    squarePath: string;
-    stalePartial?: boolean;
-    idleMs?: number;
+export declare function renderWatchOutput(history: StoredAct[], publicItems: PublicAct[], opts: {
     mention?: string;
     viewer: string;
-    showCatchHint?: boolean;
     squareState?: SquareState;
     perceptions?: ReadonlyMap<number, Perception>;
 }): string;