@ours.network/fleet 1.2.0-nightly.3 → 1.2.0-nightly.31

package/dist/agent-ours/service.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedRole } from '../config.js';
+import { AgentOursRuntime } from './runtime.js';
+export declare const privateRuntimeRoot: () => string;
+export interface ManagedAgentService {
+    runtime: AgentOursRuntime;
+    descriptor: string;
+    privatePaths: string[];
+    close(terminal: boolean): Promise<void>;
+}
+/** Only trusted launch orchestration may write this descriptor, never the child. */
+export declare function storeRoomSecret(role: ResolvedRole): void;
+export declare function storeTemporaryLaunch(role: ResolvedRole, action: string): void;
+export declare function prepareManagedAgent(role: ResolvedRole, stateDir: string, temporary: boolean): Promise<ManagedAgentService>;
+/** Explicit trusted inventory migration: read and pin existing permanent CID, never bind. */
+export declare function preparePermanentAssignment(role: ResolvedRole): Promise<'verified' | 'unverified'>;
+export declare function readRoomReadiness(roomCid: string, name: string): {
+    room: string;
+    invite: string;
+    cid: string;
+    generation: number;
+} | undefined;
+/** Explicit logical-instance termination, independent of harness/bridge transport. */
+export declare function releaseManagedAgent(role: ResolvedRole): Promise<void>;

package/dist/agent-ours/service.js

@@ -0,0 +1,372 @@
+import { socketPath as privateSocketPath } from '../socket-path.js';
+import { randomBytes, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { ApplicationIdentityStore } from '@ours.network/mcp/application-identities';
+import { readClientProfile } from '../client-profile.js';
+import { stateRoot } from '../paths.js';
+import { createCoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
+import { RuntimeController } from './controller.js';
+import { atomicPrivateWrite, binderKey } from './state.js';
+import { AgentOursRuntime } from './runtime.js';
+import { startMcpEndpoint } from './mcp-endpoint.js';
+export const privateRuntimeRoot = () => join(stateRoot(), 'private-ours');
+function roomSecretPath(role) {
+    const startup = role.roomMemberStartup;
+    return join(privateRuntimeRoot(), 'room-inputs', binderKey(startup.room_identity_cid, JSON.stringify([role.name, startup.invite_id])) + '.json');
+}
+function matchesRoomSecret(secret, role) {
+    const startup = role.roomMemberStartup;
+    return secret.room_id === startup.room_id && secret.room_identity_cid === startup.room_identity_cid
+        && secret.invite_id === startup.invite_id && secret.identity_name === role.identity
+        && secret.role === startup.role;
+}
+/** Only trusted launch orchestration may write this descriptor, never the child. */
+export function storeRoomSecret(role) {
+    const startup = role.roomMemberStartup;
+    if (!startup?.invite)
+        return;
+    if (startup.identity_name !== role.identity)
+        throw Error('ROOM_SECRET_MISMATCH');
+    const root = join(privateRuntimeRoot(), 'room-inputs');
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    // Failed attempts retain private evidence. A new invite must never overwrite
+    // or consume a previous attempt's descriptor.
+    const path = roomSecretPath(role);
+    if (existsSync(path)) {
+        const old = JSON.parse(readFileSync(path, 'utf8'));
+        if (!matchesRoomSecret(old, role) || old.invite !== startup.invite)
+            throw Error('ROOM_SECRET_COLLISION');
+        return;
+    }
+    atomicPrivateWrite(path, startup);
+}
+export function storeTemporaryLaunch(role, action) {
+    const root = join(privateRuntimeRoot(), 'launches');
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    atomicPrivateWrite(join(root, binderKey('temporary', role.name) + '.json'), {
+        role: role.name,
+        identity: role.identity,
+        action,
+    });
+}
+export async function prepareManagedAgent(role, stateDir, temporary) {
+    if (role.owner_channel?.identity === role.identity)
+        throw Error('OWNER_AGENT_IDENTITY_COLLISION');
+    const profile = readClientProfile({ ...process.env, ...role.env });
+    if (!profile)
+        throw Error('MANAGED_OURS_REQUIRES_EXPLICIT_DAEMON_PROFILE');
+    const root = privateRuntimeRoot(), key = binderKey(profile.expectedInstanceId, role.identity), dir = join(root, key);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const instancePath = join(dir, 'instance.json');
+    const launch = temporary
+        ? JSON.parse(readFileSync(join(root, 'launches', binderKey('temporary', role.name) + '.json'), 'utf8'))
+        : undefined;
+    if (launch &&
+        (launch.role !== role.name ||
+            launch.identity !== role.identity ||
+            typeof launch.action !== 'string'))
+        throw Error('INVALID_TEMP_LAUNCH');
+    let instance;
+    if (existsSync(instancePath)) {
+        const old = JSON.parse(readFileSync(instancePath, 'utf8'));
+        if (old.role !== role.name || old.temporary !== temporary)
+            throw Error('IDENTITY_ASSIGNED_TO_OTHER_ROLE');
+        instance = old.instance;
+    }
+    else {
+        instance = randomUUID();
+        try {
+            writeFileSync(instancePath, JSON.stringify({ instance, role: role.name, temporary }), {
+                flag: 'wx',
+                mode: 0o600,
+            });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const old = JSON.parse(readFileSync(instancePath, 'utf8'));
+            if (old.role !== role.name || old.temporary !== temporary)
+                throw Error('IDENTITY_ASSIGNED_TO_OTHER_ROLE');
+            instance = old.instance;
+        }
+    }
+    const controller = await RuntimeController.acquire(root, profile.expectedInstanceId, role.identity, instance);
+    let closeClient;
+    let partialEndpoint;
+    try {
+        let prior = controller.journal.read();
+        if (prior?.phase === 'RELEASED') {
+            if (temporary && launch.action === prior.action)
+                throw Error('TERMINAL_TEMP_REQUIRES_NEW_LAUNCH');
+            instance = controller.successor();
+            atomicPrivateWrite(instancePath, { instance, role: role.name, temporary });
+            if (temporary && existsSync(join(dir, 'identity-pin.json')))
+                unlinkSync(join(dir, 'identity-pin.json'));
+            prior = undefined;
+        }
+        const generation = prior ? controller.resumeGeneration() : 1;
+        const tokenPath = join(dir, 'owner.json');
+        let token;
+        if (existsSync(tokenPath)) {
+            const owner = JSON.parse(readFileSync(tokenPath, 'utf8'));
+            if (owner.instance !== instance || typeof owner.token !== 'string')
+                throw Error('OWNER_RECORD_MISMATCH');
+            token = owner.token;
+        }
+        else {
+            if (prior)
+                throw Error('OWNER_RECORD_MISSING');
+            token = randomBytes(32).toString('hex');
+            atomicPrivateWrite(tokenPath, { instance, token });
+        }
+        const client = await attachOursClient({
+            endpoint: profile.endpoint,
+            expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external',
+            leaseToken: token,
+            requiredCapabilities: ['external-sessions-v1', 'root-first-identities-v1'],
+        });
+        closeClient = () => client.close();
+        const pinPath = join(dir, 'identity-pin.json');
+        const pin = existsSync(pinPath) ? JSON.parse(readFileSync(pinPath, 'utf8')) : undefined;
+        if (pin &&
+            (pin.daemon !== profile.expectedInstanceId ||
+                pin.name !== role.identity ||
+                typeof pin.cid !== 'string'))
+            throw Error('INVALID_IDENTITY_PIN');
+        const runtime = new AgentOursRuntime({
+            instance,
+            generation,
+            daemon: profile.expectedInstanceId,
+            name: role.identity,
+            lifetime: temporary ? 'temporary' : 'permanent',
+            action: launch?.action ?? prior?.action ?? randomUUID(),
+            expectedCid: pin?.cid,
+            allowCreate: true,
+            bio: role.bio ?? '',
+        }, {
+            client,
+            journal: controller.journal,
+            assertFence: controller.assertFence,
+            now: Date.now,
+            sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        });
+        let room;
+        if (role.roomMemberStartup) {
+            const startup = role.roomMemberStartup;
+            const legacyPath = join(root, 'room-inputs', binderKey(startup.room_identity_cid, role.name) + '.json');
+            const currentPath = roomSecretPath(role);
+            const path = existsSync(currentPath) ? currentPath : legacyPath;
+            const cowork = createCoworkAdapter();
+            room = {
+                id: startup.room_id,
+                cid: startup.room_identity_cid,
+                seat: startup.invite_id,
+                action: startup.invite_id,
+                redeem: async (attached) => {
+                    const secret = JSON.parse(readFileSync(path, 'utf8'));
+                    if (!matchesRoomSecret(secret, role))
+                        throw Error('ROOM_SECRET_MISMATCH');
+                    return attached.addContact({ invite: secret.invite });
+                },
+                observe: async (agentCid) => {
+                    const [contacts, observed] = await Promise.all([
+                        client.listContacts(),
+                        cowork.getRoom(startup.room_id),
+                    ]);
+                    if (!observed || observed.identity_cid !== startup.room_identity_cid)
+                        return 'mismatch';
+                    const seat = observed.seats.find((s) => s.invite_id === startup.invite_id);
+                    if (seat && (seat.identity_cid !== agentCid || seat.role !== startup.role))
+                        return 'mismatch';
+                    return seat?.seat_state === 'active' &&
+                        contacts.contacts.some((c) => c.container_id === startup.room_identity_cid)
+                        ? 'established'
+                        : 'pending';
+                },
+                discardSecret: async () => {
+                    if (existsSync(path))
+                        unlinkSync(path);
+                },
+            };
+        }
+        await runtime.prepare(room);
+        if (role.roomMemberStartup) {
+            const startup = role.roomMemberStartup;
+            atomicPrivateWrite(join(root, 'room-inputs', binderKey(startup.room_identity_cid, role.name) + '.ready.json'), { room: startup.room_id, invite: startup.invite_id, cid: runtime.snapshot.cid, generation });
+        }
+        if (!pin)
+            atomicPrivateWrite(pinPath, {
+                daemon: profile.expectedInstanceId,
+                name: role.identity,
+                cid: runtime.snapshot.cid,
+            });
+        const identities = new ApplicationIdentityStore({ instanceId: profile.expectedInstanceId }, { path: join(dir, 'application.json') });
+        await identities.add(role.identity);
+        const bridgeDir = join(stateDir, '.ours-bridge');
+        mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+        const capability = randomBytes(32).toString('hex'), socket = privateSocketPath(join(bridgeDir, `g${generation}.sock`));
+        const endpoint = await startMcpEndpoint({
+            socket,
+            capability,
+            generation,
+            runtime,
+            client,
+            identities,
+            remoteDaemonFiles: true,
+        });
+        partialEndpoint = endpoint;
+        const descriptor = join(bridgeDir, 'descriptor.json');
+        atomicPrivateWrite(descriptor, { socket, capability, generation, role: role.name, identity: role.identity, cid: runtime.snapshot.cid });
+        return {
+            runtime,
+            descriptor,
+            privatePaths: [root, profile.configPath, profile.credentialPath],
+            close: async (terminal) => {
+                try {
+                    await endpoint.close();
+                    if (terminal)
+                        await runtime.terminal();
+                    else
+                        await runtime.suspend();
+                }
+                finally {
+                    try {
+                        await client.close();
+                    }
+                    finally {
+                        controller.unlock();
+                    }
+                }
+            },
+        };
+    }
+    catch (error) {
+        try {
+            await partialEndpoint?.close();
+        }
+        finally {
+            try {
+                await closeClient?.();
+            }
+            finally {
+                controller.unlock();
+            }
+        }
+        throw error;
+    }
+}
+/** Explicit trusted inventory migration: read and pin existing permanent CID, never bind. */
+export async function preparePermanentAssignment(role) {
+    const profile = readClientProfile({ ...process.env, ...role.env });
+    if (!profile)
+        throw Error('MANAGED_OURS_REQUIRES_EXPLICIT_DAEMON_PROFILE');
+    const client = await attachOursClient({
+        endpoint: profile.endpoint,
+        expectedInstanceId: profile.expectedInstanceId,
+        credentialPath: profile.credentialPath,
+        sessionMode: 'external',
+        leaseToken: randomUUID(),
+        requiredCapabilities: ['external-sessions-v1', 'root-first-identities-v1'],
+        env: {},
+    });
+    try {
+        const rows = await client.listIdentities(), row = rows.find((r) => r.name === role.identity);
+        if (!row)
+            return 'unverified';
+        if (!('cid' in row) || row.kind !== 'role' || row.temp)
+            throw Error('PERMANENT_ASSIGNMENT_NOT_A_ROLE');
+        const dir = join(privateRuntimeRoot(), binderKey(profile.expectedInstanceId, role.identity));
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const path = join(dir, 'identity-pin.json');
+        if (existsSync(path)) {
+            const old = JSON.parse(readFileSync(path, 'utf8'));
+            if (old.cid !== row.cid ||
+                old.daemon !== profile.expectedInstanceId ||
+                old.name !== role.identity)
+                throw Error('PERMANENT_ASSIGNMENT_PIN_MISMATCH');
+        }
+        else
+            atomicPrivateWrite(path, {
+                daemon: profile.expectedInstanceId,
+                name: role.identity,
+                cid: row.cid,
+            });
+        return 'verified';
+    }
+    finally {
+        try {
+            await client.releaseLease();
+        }
+        finally {
+            await client.close();
+        }
+    }
+}
+export function readRoomReadiness(roomCid, name) {
+    try {
+        return JSON.parse(readFileSync(join(privateRuntimeRoot(), 'room-inputs', binderKey(roomCid, name) + '.ready.json'), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+}
+/** Explicit logical-instance termination, independent of harness/bridge transport. */
+export async function releaseManagedAgent(role) {
+    const profile = readClientProfile({ ...process.env, ...role.env });
+    if (!profile)
+        throw Error('MANAGED_OURS_REQUIRES_EXPLICIT_DAEMON_PROFILE');
+    const root = privateRuntimeRoot(), dir = join(root, binderKey(profile.expectedInstanceId, role.identity));
+    if (!existsSync(join(dir, 'instance.json')))
+        return;
+    const instance = JSON.parse(readFileSync(join(dir, 'instance.json'), 'utf8'));
+    if (instance.role !== role.name)
+        throw Error('IDENTITY_ASSIGNED_TO_OTHER_ROLE');
+    const controller = await RuntimeController.acquire(root, profile.expectedInstanceId, role.identity, instance.instance);
+    try {
+        const state = controller.journal.read();
+        if (!state || state.phase === 'RELEASED')
+            return;
+        const owner = JSON.parse(readFileSync(join(dir, 'owner.json'), 'utf8'));
+        if (owner.instance !== state.instance)
+            throw Error('OWNER_RECORD_MISMATCH');
+        const client = await attachOursClient({
+            endpoint: profile.endpoint,
+            expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external',
+            leaseToken: owner.token,
+            requiredCapabilities: ['external-sessions-v1', 'root-first-identities-v1'],
+        });
+        try {
+            const runtime = new AgentOursRuntime({
+                instance: state.instance,
+                generation: state.generation,
+                daemon: state.daemon,
+                name: state.name,
+                lifetime: state.lifetime,
+                action: state.action,
+                allowCreate: false,
+                bio: '',
+            }, {
+                client,
+                journal: controller.journal,
+                assertFence: controller.assertFence,
+                now: Date.now,
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+            });
+            await runtime.terminal();
+        }
+        finally {
+            await client.close();
+        }
+    }
+    finally {
+        controller.unlock();
+    }
+}

package/dist/agent-ours/state.d.ts

@@ -0,0 +1,45 @@
+export type Phase = 'PREPARING' | 'OWNED' | 'ROOM_PENDING' | 'READY' | 'SERVING' | 'RECOVERING' | 'QUIESCING' | 'TERMINAL_INTENT' | 'RELEASED' | 'FAILED' | 'CLEANUP_PENDING';
+export interface RuntimeState {
+    version: 1;
+    instance: string;
+    generation: number;
+    daemon: string;
+    name: string;
+    cid?: string;
+    lifetime: 'permanent' | 'temporary';
+    action: string;
+    phase: Phase;
+    revision: number;
+    updatedAt: string;
+    admissionIntent?: {
+        id: string;
+        cid: string;
+        seat: string;
+        action: string;
+        agentCid: string;
+    };
+    releaseAck?: {
+        released: string[];
+        closed: string[];
+        attempted: number;
+        notified: number;
+        failed: number;
+    };
+    room?: {
+        id: string;
+        cid: string;
+        seat: string;
+        agentCid: string;
+        action: string;
+    };
+}
+export declare function atomicPrivateWrite(path: string, value: unknown): void;
+export declare function binderKey(daemon: string, identity: string): string;
+/** Supervisor-owned durable state; retained across harness reconnects. */
+export declare class RuntimeJournal {
+    readonly privateDir: string;
+    readonly path: string;
+    constructor(privateDir: string);
+    read(): RuntimeState | undefined;
+    commit(next: RuntimeState, expectedRevision?: number): void;
+}

package/dist/agent-ours/state.js

@@ -0,0 +1,95 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+const phases = [
+    'PREPARING',
+    'OWNED',
+    'ROOM_PENDING',
+    'READY',
+    'SERVING',
+    'RECOVERING',
+    'QUIESCING',
+    'TERMINAL_INTENT',
+    'RELEASED',
+    'FAILED',
+    'CLEANUP_PENDING',
+];
+export function atomicPrivateWrite(path, value) {
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    const fd = openSync(tmp, 'wx', 0o600);
+    try {
+        writeFileSync(fd, JSON.stringify(value) + '\n');
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, path);
+    const parent = openSync(join(path, '..'), 'r');
+    try {
+        fsyncSync(parent);
+    }
+    finally {
+        closeSync(parent);
+    }
+}
+export function binderKey(daemon, identity) {
+    return createHash('sha256')
+        .update(JSON.stringify([daemon, identity]))
+        .digest('hex');
+}
+/** Supervisor-owned durable state; retained across harness reconnects. */
+export class RuntimeJournal {
+    privateDir;
+    path;
+    constructor(privateDir) {
+        this.privateDir = privateDir;
+        mkdirSync(privateDir, { recursive: true, mode: 0o700 });
+        this.path = join(privateDir, 'state.json');
+    }
+    read() {
+        let raw;
+        try {
+            raw = readFileSync(this.path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        const s = JSON.parse(raw);
+        if (s.version !== 1 ||
+            !s.instance ||
+            !s.daemon ||
+            !s.name ||
+            !s.action ||
+            !phases.includes(s.phase) ||
+            !Number.isSafeInteger(s.generation) ||
+            s.generation < 1 ||
+            !Number.isSafeInteger(s.revision) ||
+            !['permanent', 'temporary'].includes(s.lifetime))
+            throw Error('CORRUPT_RUNTIME_JOURNAL');
+        return s;
+    }
+    commit(next, expectedRevision) {
+        const current = this.read();
+        if (current?.revision !== expectedRevision)
+            throw Error('STALE_RUNTIME_REVISION');
+        if (current &&
+            (current.instance !== next.instance ||
+                current.daemon !== next.daemon ||
+                current.name !== next.name ||
+                current.lifetime !== next.lifetime ||
+                next.generation < current.generation))
+            throw Error('RUNTIME_IDENTITY_MISMATCH');
+        if (current &&
+            ['TERMINAL_INTENT', 'CLEANUP_PENDING', 'RELEASED'].includes(current.phase) &&
+            !['TERMINAL_INTENT', 'CLEANUP_PENDING', 'RELEASED'].includes(next.phase))
+            throw Error('RETIRED_RUNTIME');
+        atomicPrivateWrite(this.path, {
+            ...next,
+            revision: (expectedRevision ?? 0) + 1,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+}

package/dist/agent-ours/wire.d.ts

@@ -0,0 +1,14 @@
+import type { Socket } from 'node:net';
+export declare const MAX_FRAME_BYTES: number;
+export declare const MAX_CHUNK_BYTES: number;
+/** One bounded framed channel. No request replay after disconnect. */
+export declare class Wire {
+    readonly socket: Socket;
+    private buffer;
+    private ended;
+    onFrame: (frame: unknown) => void;
+    onClose: () => void;
+    constructor(socket: Socket);
+    send(frame: unknown): Promise<void>;
+    close(): void;
+}

package/dist/agent-ours/wire.js

@@ -0,0 +1,55 @@
+export const MAX_FRAME_BYTES = 1024 * 1024;
+export const MAX_CHUNK_BYTES = 64 * 1024;
+/** One bounded framed channel. No request replay after disconnect. */
+export class Wire {
+    socket;
+    buffer = Buffer.alloc(0);
+    ended = false;
+    onFrame = () => { };
+    onClose = () => { };
+    constructor(socket) {
+        this.socket = socket;
+        socket.on('data', (chunk) => {
+            this.buffer = Buffer.concat([this.buffer, chunk]);
+            for (;;) {
+                const end = this.buffer.indexOf(10);
+                if (end < 0) {
+                    if (this.buffer.length > MAX_FRAME_BYTES)
+                        socket.destroy();
+                    return;
+                }
+                if (end > MAX_FRAME_BYTES) {
+                    socket.destroy();
+                    return;
+                }
+                const line = this.buffer.subarray(0, end);
+                this.buffer = this.buffer.subarray(end + 1);
+                try {
+                    this.onFrame(JSON.parse(line.toString('utf8')));
+                }
+                catch {
+                    socket.destroy();
+                    return;
+                }
+            }
+        });
+        socket.on('error', () => socket.destroy());
+        socket.on('close', () => {
+            if (!this.ended) {
+                this.ended = true;
+                this.onClose();
+            }
+        });
+    }
+    async send(frame) {
+        if (this.ended || this.socket.destroyed)
+            throw Error('BRIDGE_DISCONNECTED');
+        const bytes = Buffer.from(JSON.stringify(frame) + '\n');
+        if (bytes.length > MAX_FRAME_BYTES)
+            throw Error('FRAME_TOO_LARGE');
+        await new Promise((resolve, reject) => this.socket.write(bytes, (error) => (error ? reject(error) : resolve())));
+    }
+    close() {
+        this.socket.destroy();
+    }
+}

package/dist/application/conversation-history.d.ts

@@ -0,0 +1,25 @@
+import type { ConversationEventV1 } from '../session/conversation-types.js';
+import type { ConversationPageView } from './session-control.js';
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export declare function conversationEventVisible(event: ConversationEventV1, sessionGeneration: string, resumedSessionId?: string): boolean;
+export interface ConversationTailPage extends ConversationPageView {
+    /** Pass as `before` to read the next older page. */
+    olderCursor?: string;
+    hasOlder: boolean;
+    /** Latest page only: older events the view still needs, the current session's latest capabilities and still-pending permission requests. */
+    context: ConversationEventV1[];
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export declare function conversationTailPage(stateDir: string, request: {
+    before?: string;
+    limit?: number;
+}, snapshot: ConversationPageView['snapshot'], resumedSessionId?: string): Promise<ConversationTailPage>;
+/** Read the existing ACP session ledger without opening its writer/recovery store. */
+export declare function resumedConversationPage(stateDir: string, request: {
+    after?: string;
+    limit?: number;
+}, live: ConversationPageView, expectedSessionId: string): Promise<ConversationPageView>;