@ours.network/fleet 1.2.0-nightly.9 → 2.0.1

package/dist/session/control.js

@@ -1,14 +1,16 @@
+import { socketPath as privateSocketPath } from '../socket-path.js';
 import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
 import { join } from 'node:path';
 import { SessionControlError } from './types.js';
+import { MAX_CONVERSATION_RECORD_BYTES, startConversationReplay } from './conversation-replay.js';
 import { validateFleetAuditBegin, validateFleetAuditFinish, validateFleetAuditPresentations, } from '../fleet-command-audit.js';
 import { interruptSession, queueSessionPrompt, respondSessionPermission, respondSessionPermissionV2, } from '../application/session-mutations.js';
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
 const V3_COMMANDS = new Set([
-    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'interrupt_v2',
+    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'submit_voice_prompt', 'interrupt_v2', 'interrupt_voice_v2',
     'respond_permission_v2',
 ]);
 /** The one retained-range projection shared by polling and live-follow admission. */
@@ -99,7 +101,7 @@ export function oversightTaxonomy(name = '<Name>') {
 export function oversightTaxonomyLines(name = '<Name>') {
     return oversightTaxonomy(name).map(r => `- **${r.result}** — ${r.meaning} → ${r.action}`);
 }
-export const controlSocketPath = (stateDir) => join(stateDir, '.control.sock');
+export const controlSocketPath = (stateDir) => privateSocketPath(join(stateDir, '.control.sock'));
 export const controlTokenPath = (stateDir) => join(stateDir, '.control-token');
 function sameToken(actual, supplied) {
     const a = Buffer.from(actual);
@@ -116,9 +118,13 @@ export class RoleControlServer {
     sockets = new Set();
     /** Interrupt idempotency: same command id returns the first receipt. */
     interruptCommands = new Map();
+    correspondence;
+    setCorrespondence(value) { this.correspondence = value; }
     ownerChannel;
     loopManager;
     reloadConfig;
+    layoutControl;
+    setLayoutControl(handler) { this.layoutControl = handler; }
     fleetSpawner;
     fleetAuditor;
     constructor(stateDir, session, log) {
@@ -189,6 +195,12 @@ export class RoleControlServer {
                     continue;
                 void this.handle(line, socket).then(follow => {
                     if (follow) {
+                        if (socket.destroyed) {
+                            follow.stop();
+                            if (follow.controller)
+                                this.session.setControllerAttached(false);
+                            return;
+                        }
                         if (unsubscribe) {
                             unsubscribe();
                             if (controllerAttached)
@@ -235,7 +247,11 @@ export class RoleControlServer {
                             protocolVersion: this.session.conversationPage ? 3 : 2,
                             features: [
                                 'events_since', 'observer_follow', 'retained_range',
+                                ...(this.correspondence ? ['agent_correspondence'] : []),
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
+                                ...this.observationFeatures(),
+                                ...(this.session.submitPromptBrowser ? ['generation_bound_prompts'] : []),
+                                ...(this.session.liveVoiceSupported ? ['idle_bound_prompts', 'targeted_voice_interrupt'] : []),
                                 ...(this.session.capabilities?.steering ? ['steering'] : []),
                                 ...(this.session.capabilities?.permissions ? ['permissions'] : []),
                                 ...(this.session.capabilities?.messagePhases ? ['message_phases'] : []),
@@ -308,6 +324,13 @@ export class RoleControlServer {
                     });
                     return;
                 }
+                case 'layout_control': {
+                    if (request.version !== 2 || !request.layout || !this.layoutControl)
+                        throw new SessionControlError('rejected', 'layout control unavailable');
+                    const result = await this.layoutControl(request.layout);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'fleet_spawn': {
                     if (request.version !== 2 || !request.spawn || typeof request.spawn.name !== 'string')
                         throw new SessionControlError('rejected', 'version 2 and typed spawn options are required');
@@ -362,6 +385,23 @@ export class RoleControlServer {
                     this.write(socket, { version: 1, id: request.id, ok: true, result: { delivered: true } });
                     return;
                 }
+                case 'agent_contacts':
+                case 'agent_history': {
+                    if (!this.correspondence)
+                        throw new SessionControlError('rejected', 'Supervisor correspondence API is unavailable; this session needs an updated supervisor.');
+                    const query = request.agentHistory;
+                    if (request.command === 'agent_history' && (!query || !/^[a-f0-9]{64}$/i.test(query.peer_cid) || (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200)) || (query.before_seq !== undefined && (!Number.isSafeInteger(query.before_seq) || query.before_seq < 1))))
+                        throw new SessionControlError('rejected', 'Valid peer_cid, limit (1–200) and before_seq are required.');
+                    let result;
+                    try {
+                        result = request.command === 'agent_contacts' ? await this.correspondence.contacts() : await this.correspondence.history(query);
+                    }
+                    catch {
+                        throw new SessionControlError('rejected', 'Supervisor correspondence read failed; identity or transport is unavailable.');
+                    }
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'owner_channel_manage': {
                     if (!request.ownerChannel || typeof request.ownerChannel.action !== 'string')
                         throw new SessionControlError('rejected', 'owner-channel management action is required');
@@ -395,20 +435,104 @@ export class RoleControlServer {
                 }
                 case 'conversation_page': {
                     this.requireConversation(request);
-                    this.write(socket, {
-                        version: 1, id: request.id, ok: true,
-                        result: this.session.conversationPage({
-                            after: request.after, limit: request.limit,
-                        }),
+                    const page = this.session.conversationPage({
+                        after: request.after === undefined ? undefined : String(request.after), limit: request.limit,
                     });
+                    if (this.session.observeConversation) {
+                        try {
+                            const observation = this.session.observeConversation(() => { });
+                            try {
+                                if (observation.snapshot.observationFailure) {
+                                    page.snapshot = { ...page.snapshot, historyDegraded: true, observationFailure: 'capture_failed' };
+                                }
+                                else
+                                    page.snapshot = observation.snapshot;
+                            }
+                            finally {
+                                observation.unsubscribe();
+                            }
+                        }
+                        catch {
+                            // Canonical REST recovery remains usable without a live observation.
+                            // Never substitute a frozen capture/barrier for the current store page.
+                            page.snapshot = { ...page.snapshot, historyDegraded: true, observationFailure: 'capture_failed' };
+                        }
+                    }
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: page });
                     return;
                 }
                 case 'conversation_follow': {
                     this.requireConversation(request);
+                    if (request.controller === false && request.expectedGeneration !== undefined) {
+                        let stopped = false;
+                        let heartbeat;
+                        let writing = Promise.resolve();
+                        let lastQualifyingOutputAt = Date.now();
+                        const send = (message) => {
+                            const result = writing.then(async () => {
+                                if (message.controlHeartbeat === true && Date.now() - lastQualifyingOutputAt < 15_000)
+                                    return;
+                                await writeMessage(message);
+                                lastQualifyingOutputAt = Date.now();
+                            });
+                            writing = result.catch(() => { });
+                            return result;
+                        };
+                        const writeMessage = async (message) => {
+                            // Stream one replay record progressively; don't queue a valid 16 MiB record
+                            // into the 8 MiB pending-output budget. Framing is owned by the transport.
+                            const bytes = Buffer.from(JSON.stringify({ version: 1, ...message }) + '\n');
+                            for (let offset = 0; offset < bytes.length; offset += 64 * 1024) {
+                                if (stopped || socket.destroyed)
+                                    throw new Error('conversation socket closed');
+                                if (!socket.write(bytes.subarray(offset, offset + 64 * 1024))) {
+                                    await new Promise((resolve, reject) => {
+                                        const cleanup = () => { socket.off('drain', drained); socket.off('close', ended); socket.off('error', failed); };
+                                        const drained = () => { cleanup(); resolve(); };
+                                        const ended = () => { cleanup(); reject(new Error('conversation socket closed')); };
+                                        const failed = (error) => { cleanup(); reject(error); };
+                                        socket.once('drain', drained);
+                                        socket.once('close', ended);
+                                        socket.once('error', failed);
+                                    });
+                                }
+                            }
+                        };
+                        const follow = startConversationReplay(this.session, {
+                            expectedGeneration: request.expectedGeneration, after: request.after === undefined ? 0 : Number(request.after), controller: false,
+                        }, {
+                            replay: page => send({ conversationReplay: page }),
+                            ready: ready => send({ conversationReady: ready }),
+                            event: event => send({ conversationEvent: event }),
+                            state: state => send({ conversationState: state }),
+                            close: reason => {
+                                stopped = true;
+                                if (heartbeat)
+                                    clearInterval(heartbeat);
+                                if (reason && !socket.destroyed)
+                                    socket.end(JSON.stringify({ version: 1, id: request.id, ok: false, error: reason }) + '\n');
+                            },
+                        });
+                        const stop = () => { stopped = true; if (heartbeat)
+                            clearInterval(heartbeat); follow.close(); };
+                        let heartbeatPending = false;
+                        if (!stopped) {
+                            heartbeat = setInterval(() => {
+                                if (heartbeatPending || stopped)
+                                    return;
+                                heartbeatPending = true;
+                                void send({ controlHeartbeat: true }).catch(() => { stop(); socket.destroy(); })
+                                    .finally(() => { heartbeatPending = false; });
+                            }, 15_000);
+                            heartbeat.unref();
+                        }
+                        socket.once('close', stop);
+                        return { controller: false, stop: () => { socket.off('close', stop); stop(); } };
+                    }
                     this.write(socket, {
                         version: 1, id: request.id, ok: true,
                         result: this.session.conversationPage({
-                            after: request.after, limit: request.limit,
+                            after: request.after === undefined ? undefined : String(request.after), limit: request.limit,
                         }),
                     });
                     // A live conversation view is an attached controller: permission
@@ -421,7 +545,10 @@ export class RoleControlServer {
                                 socket.write(JSON.stringify({ version: 1, conversationEvent: event }) + '\n');
                         }) };
                 }
+                case 'submit_voice_prompt':
                 case 'submit_prompt_v2': {
+                    if (request.command === 'submit_voice_prompt' && !request.expectedSessionGeneration?.trim())
+                        throw new SessionControlError('rejected', 'expectedSessionGeneration is required');
                     this.requireConversation(request);
                     if (!request.commandId?.trim() || !request.text?.trim() || !request.actor?.trim()
                         || request.source !== 'owner_admin_console')
@@ -432,6 +559,7 @@ export class RoleControlServer {
                         const receipt = await this.session.submitPromptBrowser({
                             commandId: request.commandId, text: request.text,
                             source: 'owner_admin_console', actorBrowserSession: request.actor,
+                            expectedSessionGeneration: request.expectedSessionGeneration, requireIdle: request.requireIdle === true,
                         });
                         this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
                     }
@@ -442,6 +570,29 @@ export class RoleControlServer {
                     }
                     return;
                 }
+                case 'interrupt_voice_v2': {
+                    this.requireConversation(request);
+                    if (!request.commandId?.trim() || !request.expectedSessionGeneration?.trim() || !request.promptId?.trim())
+                        throw new SessionControlError('rejected', 'commandId, expectedSessionGeneration and promptId are required');
+                    if (!this.session.interruptPrompt)
+                        throw new SessionControlError('rejected', 'targeted voice interrupt unavailable');
+                    const key = 'voice:' + request.commandId;
+                    const signature = JSON.stringify([request.expectedSessionGeneration, request.promptId]);
+                    const existing = this.interruptCommands.get(key);
+                    if (existing) {
+                        if (existing.signature !== signature)
+                            throw new SessionControlError('rejected', 'idempotency_conflict: interrupt target changed');
+                        this.write(socket, { version: 1, id: request.id, ok: true, result: existing.receipt });
+                        return;
+                    }
+                    const outcome = await this.session.interruptPrompt(request.expectedSessionGeneration, request.promptId);
+                    const receipt = { accepted: true, commandId: request.commandId, ...outcome };
+                    this.interruptCommands.set(key, { signature, receipt });
+                    if (this.interruptCommands.size > 200)
+                        this.interruptCommands.delete(this.interruptCommands.keys().next().value);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
+                    return;
+                }
                 case 'interrupt_v2': {
                     this.requireConversation(request);
                     if (!request.commandId?.trim())
@@ -501,6 +652,23 @@ export class RoleControlServer {
         if (!this.session.conversationPage || !this.session.subscribeConversation)
             throw new SessionControlError('rejected', 'this role has no conversation ledger');
     }
+    observationFeatures() {
+        if (!this.session.observeConversation || !this.session.replayConversation || !this.session.subscribeConversation || !this.session.subscribeConversationFailure)
+            return [];
+        try {
+            const observation = this.session.observeConversation(() => { });
+            try {
+                return observation.snapshot.observationFailure || !this.session.conversationReplayAvailable?.(observation.snapshot.sessionGeneration)
+                    ? [] : ['conversation_observation', 'control_heartbeat'];
+            }
+            finally {
+                observation.unsubscribe();
+            }
+        }
+        catch {
+            return [];
+        }
+    }
     write(socket, response) {
         if (!socket.destroyed)
             socket.write(JSON.stringify(response) + '\n');
@@ -532,7 +700,13 @@ export async function controlRequest(stateDir, request, timeoutMs = 120_000) {
         socket.once('error', error => {
             clearTimeout(timer);
             const code = error.code;
-            reject(new SessionControlError(code === 'ENOENT' || code === 'ECONNREFUSED' ? 'control-unavailable' : 'backend', `role control socket: ${error.message}`));
+            const permissionHint = code === 'EPERM' || code === 'EACCES'
+                ? `; the operating system denied access before '${request.command}' reached the supervisor. `
+                    + 'Check socket permissions and the command execution sandbox. '
+                    + 'An existing socket does not prove this process can connect; do not bypass Fleet audit. '
+                    + 'For managed workspace sessions, see docs/validation/managed-cli-permissions.md.'
+                : '';
+            reject(new SessionControlError(code === 'ENOENT' || code === 'ECONNREFUSED' ? 'control-unavailable' : 'backend', `role control socket: ${error.message}${permissionHint}`));
         });
         socket.on('data', chunk => {
             buffer += chunk;
@@ -587,32 +761,54 @@ export async function followControl(stateDir, onMessage) {
  * controller-presence this connection contributed.
  */
 export async function followConversation(stateDir, after, onMessage) {
+    const options = typeof after === 'object' ? after : undefined;
+    options?.signal?.throwIfAborted();
     const token = readFileSync(controlTokenPath(stateDir), 'utf8').trim();
     const socket = createConnection(controlSocketPath(stateDir));
     socket.setEncoding('utf8');
-    let buffer = '';
+    // Admit one maximum-size logical record plus its actual private wrapper.
+    // coveredThrough is a safe integer. JSON brackets/envelope are outside the record budget.
+    const privateEnvelopeBytes = Math.max(Buffer.byteLength(JSON.stringify({ version: 1, conversationReplay: { events: [], coveredThrough: Number.MAX_SAFE_INTEGER } })), Buffer.byteLength(JSON.stringify({ version: 1, conversationReady: { snapshot: null, coveredThrough: Number.MAX_SAFE_INTEGER } })) - 4, Buffer.byteLength(JSON.stringify({ version: 1, conversationState: null })) - 4, Buffer.byteLength(JSON.stringify({ version: 1, conversationEvent: null })) - 4);
+    const limit = MAX_CONVERSATION_RECORD_BYTES + privateEnvelopeBytes;
+    let parts = [], bytes = 0;
     socket.on('data', chunk => {
-        buffer += chunk;
-        for (;;) {
-            const newline = buffer.indexOf('\n');
-            if (newline < 0)
-                break;
-            const line = buffer.slice(0, newline);
-            buffer = buffer.slice(newline + 1);
-            if (!line.trim())
-                continue;
-            try {
-                onMessage(JSON.parse(line));
+        for (const [index, part] of String(chunk).split('\n').entries()) {
+            if (index) {
+                const line = parts.join('');
+                parts = [];
+                bytes = 0;
+                if (line.trim()) {
+                    try {
+                        onMessage(JSON.parse(line));
+                    }
+                    catch {
+                        if (options) {
+                            socket.destroy(new Error('invalid conversation private frame'));
+                            return;
+                        }
+                    }
+                }
+            }
+            bytes += Buffer.byteLength(part);
+            if (options && bytes > limit) {
+                socket.destroy(new Error('conversation private frame exceeds assembly limit'));
+                return;
             }
-            catch { /* a torn frame ends this stream; the client resyncs over HTTP */ }
+            parts.push(part);
         }
     });
     await new Promise((resolve, reject) => {
+        const onAbort = () => { socket.destroy(); reject(new Error('conversation follow aborted')); };
+        options?.signal?.addEventListener('abort', onAbort, { once: true });
+        socket.once('close', () => options?.signal?.removeEventListener('abort', onAbort));
         socket.once('connect', resolve);
         socket.once('error', reject);
+        if (options?.signal?.aborted)
+            onAbort();
     });
     socket.write(JSON.stringify({
-        version: 3, id: randomUUID(), token, command: 'conversation_follow', after,
+        version: 3, id: randomUUID(), token, command: 'conversation_follow',
+        ...(options ? { expectedGeneration: options.expectedGeneration, after: options.after ?? 0, controller: false } : { after }),
     }) + '\n');
     return { socket, close: () => socket.destroy() };
 }

package/dist/session/conversation-normalizer.d.ts

@@ -1,5 +1,5 @@
 import type * as acp from '@agentclientprotocol/sdk';
-import type { AdapterMeta, ConversationEventKind, ConversationPayload } from './conversation-types.js';
+import type { AdapterMeta, BoundedJson, ConversationEventKind, ConversationPayload } from './conversation-types.js';
 /**
  * Reduce one ACP v1 `session/update` into one conversation-domain event draft.
  *
@@ -43,4 +43,5 @@ export interface NormalizedUpdate {
     toolCallId?: string;
     adapterMeta?: AdapterMeta[];
 }
+export declare function boundedJson(value: unknown): BoundedJson;
 export declare function normalizeSessionUpdate(update: acp.SessionUpdate, options?: NormalizeOptions): NormalizedUpdate;

package/dist/session/conversation-normalizer.js

@@ -246,7 +246,7 @@ function redactSensitiveJson(value) {
     };
     return { value: visit(value, 0), redacted };
 }
-function boundedJson(value) {
+export function boundedJson(value) {
     let serialized;
     let safe;
     let redacted = false;

package/dist/session/conversation-observation.d.ts

@@ -0,0 +1,25 @@
+import type { ConversationObservation as Observation, ConversationObservationState } from './conversation-types.js';
+type Capture = () => Omit<ConversationObservationState, 'stateRevision'>;
+/** Revision/publication only: the backend remains the sole owner of snapshot construction. */
+export declare class ConversationObservation {
+    private readonly capture;
+    private revision;
+    private fingerprint?;
+    private current?;
+    private scheduled;
+    private checkpointDepth;
+    private failed;
+    private readonly listeners;
+    constructor(capture: Capture);
+    observe(listener: (state: ConversationObservationState) => void): Observation;
+    /** Keep reentrant registration on the preceding coherent snapshot until the
+     * owner's synchronous durable append and inventory mutation finish together.
+     */
+    checkpoint<T>(mutation: () => T): T;
+    publish(): void;
+    private failCapture;
+    private deliver;
+    /** Fresh capture after a durable append's synchronous owner mutation completes. */
+    scheduleCapture(): void;
+}
+export {};

package/dist/session/conversation-observation.js

@@ -0,0 +1,100 @@
+/** Revision/publication only: the backend remains the sole owner of snapshot construction. */
+export class ConversationObservation {
+    capture;
+    revision = 0;
+    fingerprint;
+    current;
+    scheduled = false;
+    checkpointDepth = 0;
+    failed = false;
+    listeners = new Set();
+    constructor(capture) {
+        this.capture = capture;
+    }
+    observe(listener) {
+        // Registration and synchronous stable capture have no await gap. Inside an
+        // owner checkpoint, publish retains the preceding snapshot and its barrier.
+        // A reconnect never resets this generation's revision or implies control.
+        this.publish();
+        if (!this.current)
+            throw new Error('conversation observation unavailable: capture_failed');
+        this.listeners.add(listener);
+        return {
+            snapshot: structuredClone(this.current),
+            unsubscribe: () => { this.listeners.delete(listener); },
+        };
+    }
+    /** Keep reentrant registration on the preceding coherent snapshot until the
+     * owner's synchronous durable append and inventory mutation finish together.
+     */
+    checkpoint(mutation) {
+        if (this.checkpointDepth === 0)
+            this.publish();
+        this.checkpointDepth++;
+        try {
+            return mutation();
+        }
+        finally {
+            this.checkpointDepth--;
+            if (this.checkpointDepth === 0)
+                this.publish();
+        }
+    }
+    publish() {
+        if (this.checkpointDepth > 0 || this.failed)
+            return;
+        try {
+            const captured = this.capture();
+            const fingerprint = JSON.stringify(captured);
+            if (fingerprint === this.fingerprint)
+                return;
+            const current = structuredClone({ ...captured, stateRevision: this.revision + 1 });
+            this.fingerprint = fingerprint;
+            this.current = current;
+            this.revision++;
+        }
+        catch {
+            this.failCapture();
+            return;
+        }
+        this.deliver();
+    }
+    failCapture() {
+        if (this.failed)
+            return;
+        this.failed = true;
+        // Retain the entire preceding coherent state and its barrier. Consumers
+        // must stop healthy coverage; owner admission/receipt processing continues.
+        if (this.current) {
+            this.current = { ...this.current, stateRevision: ++this.revision, observationFailure: 'capture_failed' };
+            this.deliver();
+        }
+    }
+    deliver() {
+        for (const listener of this.listeners) {
+            let state;
+            try {
+                state = structuredClone(this.current);
+            }
+            catch {
+                this.failCapture();
+                return;
+            }
+            // An observer callback cannot break the owning backend's transition.
+            try {
+                listener(state);
+            }
+            catch { /* passive observer */ }
+        }
+    }
+    /** Fresh capture after a durable append's synchronous owner mutation completes. */
+    scheduleCapture() {
+        if (this.scheduled)
+            return;
+        this.scheduled = true;
+        queueMicrotask(() => {
+            this.scheduled = false;
+            this.publish();
+        });
+    }
+}

package/dist/session/conversation-replay.d.ts

@@ -0,0 +1,50 @@
+import type { ConversationEventV1 } from './conversation-types.js';
+export declare const MAX_REPLAY_BUFFER_BYTES: number;
+export declare const MAX_CONVERSATION_RECORD_BYTES: number;
+export interface ConversationReplayRequest {
+    expectedGeneration: string;
+    after: number;
+    through: number;
+    pageSize?: number;
+    signal?: AbortSignal;
+}
+export interface ConversationReplayPage {
+    events: ConversationEventV1[];
+    /** Storage coverage, including invisible events; never a visible-event cursor. */
+    coveredThrough: number;
+}
+export declare class ReplayCoverageError extends Error {
+    constructor(detail: string);
+}
+/** Bounded reads and explicit scheduling even when a whole segment is cached by the OS. */
+export declare function replayLines(path: string, signal?: AbortSignal): AsyncGenerator<string>;
+import type { ConversationObservation, ConversationObservationState } from './conversation-types.js';
+export interface PassiveConversationFollowRequest {
+    expectedGeneration: string;
+    after?: number;
+    controller: false;
+    signal?: AbortSignal;
+}
+export interface ConversationReplayReady {
+    snapshot: ConversationObservationState;
+    coveredThrough: number;
+}
+interface ReplayOwner {
+    observeConversation?(listener: (state: ConversationObservationState) => void): ConversationObservation;
+    subscribeConversationFailure?(listener: (generation: string) => void): () => void;
+    subscribeConversation?(listener: (event: ConversationEventV1) => void): () => void;
+    replayConversation?(request: ConversationReplayRequest): AsyncIterable<ConversationReplayPage>;
+}
+export interface ConversationReplaySink {
+    replay(page: ConversationReplayPage): void | Promise<void>;
+    ready(ready: ConversationReplayReady): void | Promise<void>;
+    event(event: ConversationEventV1): void | Promise<void>;
+    state(state: ConversationObservationState): void | Promise<void>;
+    close(reason?: string): void;
+}
+/** Passive owner-turn registration, complete replay, ready, then buffered post-barrier delivery. */
+export declare function startConversationReplay(owner: ReplayOwner, request: PassiveConversationFollowRequest, sink: ConversationReplaySink): {
+    ready: Promise<void>;
+    close: () => void;
+};
+export {};