@ours.network/fleet 1.2.0-nightly.22 → 1.2.0-nightly.23

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

@@ -1,4 +1,23 @@
+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;

package/dist/application/conversation-history.js

@@ -1,7 +1,127 @@
 import { createReadStream } from 'node:fs';
-import { readFile, readdir } from 'node:fs/promises';
+import { open, readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
+const HISTORICAL_KINDS = ['fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export function conversationEventVisible(event, sessionGeneration, resumedSessionId) {
+    return event.source !== 'agent_replay' && (event.sessionGeneration === sessionGeneration || (!!resumedSessionId && HISTORICAL_KINDS.includes(event.kind) && event.acpSessionId === resumedSessionId));
+}
+/** Newest-first lines of a file, read in chunks from its end; `visit` returns false to stop. */
+async function readLinesBackward(path, visit) {
+    const file = await open(path, 'r');
+    try {
+        let position = (await file.stat()).size;
+        let carry = Buffer.alloc(0);
+        while (position > 0) {
+            const size = Math.min(256 * 1024, position);
+            position -= size;
+            const chunk = Buffer.alloc(size);
+            await file.read(chunk, 0, size, position);
+            let buffer = Buffer.concat([chunk, carry]);
+            let end = buffer.length;
+            for (let i = buffer.length - 1; i >= 0; i--) {
+                if (buffer[i] !== 10)
+                    continue;
+                if (end > i + 1 && !visit(buffer.toString('utf8', i + 1, end)))
+                    return false;
+                end = i;
+            }
+            carry = buffer.subarray(0, end);
+        }
+        if (carry.length && !visit(carry.toString('utf8')))
+            return false;
+        return true;
+    }
+    finally {
+        await file.close();
+    }
+}
+/** The last event cursor in a segment, read from its tail; undefined when none is readable. */
+async function lastSeq(path) {
+    let seq;
+    await readLinesBackward(path, line => { try {
+        const value = Number(JSON.parse(line).seq);
+        if (Number.isSafeInteger(value)) {
+            seq = value;
+            return false;
+        }
+    }
+    catch { } return true; });
+    return seq;
+}
+/**
+ * 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 async function conversationTailPage(stateDir, request, snapshot, resumedSessionId) {
+    const before = request.before === undefined ? Infinity : Number(request.before);
+    if (before !== Infinity && (!Number.isSafeInteger(before) || before < 0))
+        throw new Error('before must be a ledger cursor');
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    let files = [];
+    try {
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort().reverse();
+    }
+    catch { }
+    const events = [];
+    let newest;
+    let hasOlder = false;
+    const pending = new Set(snapshot.pendingPermissionIds);
+    let capabilities;
+    const context = [];
+    // Context only accompanies the newest page; older pages stop as soon as they are full.
+    const wantsContext = () => before === Infinity && (!capabilities || pending.size > 0);
+    const generation = `"sessionGeneration":${JSON.stringify(snapshot.sessionGeneration)}`;
+    for (const file of files) {
+        const more = await readLinesBackward(join(stateDir, '.conversation', file), line => {
+            if (hasOlder) {
+                // The page is full; only the current generation's context kinds matter. Generations are
+                // appended in order, so the first line of an older one ends the search.
+                if (!line.includes(generation))
+                    return !line.includes('"sessionGeneration":') && wantsContext();
+                if (!line.includes('"capabilities.updated"') && !line.includes('"permission.requested"'))
+                    return wantsContext();
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return true;
+            }
+            const seq = Number(event.seq);
+            if (!Number.isSafeInteger(seq))
+                return true;
+            newest ??= seq;
+            if (seq < before && conversationEventVisible(event, snapshot.sessionGeneration, resumedSessionId)) {
+                const inPage = !hasOlder && events.length < limit;
+                if (event.sessionGeneration === snapshot.sessionGeneration) {
+                    if (event.kind === 'capabilities.updated' && !capabilities) {
+                        capabilities = event;
+                        if (!inPage)
+                            context.push(event);
+                    }
+                    if (event.kind === 'permission.requested' && event.permissionId && pending.delete(event.permissionId) && !inPage)
+                        context.push(event);
+                }
+                if (inPage)
+                    events.push(event);
+                else
+                    hasOlder = true;
+            }
+            return !hasOlder || wantsContext();
+        });
+        if (!more)
+            break;
+    }
+    events.reverse();
+    context.reverse();
+    return { events, snapshot, hasOlder, context, hasMore: false,
+        ...(events.length ? { olderCursor: String(events[0].seq) } : {}),
+        ...(before === Infinity && newest !== undefined ? { nextCursor: String(newest) } : {}) };
+}
 /** Read the existing ACP session ledger without opening its writer/recovery store. */
 export async function resumedConversationPage(stateDir, request, live, expectedSessionId) {
     let sessionId;
@@ -24,6 +144,10 @@ export async function resumedConversationPage(stateDir, request, live, expectedS
     let first;
     let hasMore = false;
     scan: for (const file of files) {
+        // Forward polling asks for the newest few events: skip whole segments that end at or before the cursor.
+        const end = await lastSeq(join(stateDir, '.conversation', file));
+        if (end !== undefined && end <= after)
+            continue;
         const input = createReadStream(join(stateDir, '.conversation', file), { encoding: 'utf8' });
         const lines = createInterface({ input, crlfDelay: Infinity });
         try {

package/dist/application/session-control.d.ts

@@ -1,3 +1,4 @@
+import { type ConversationTailPage } from './conversation-history.js';
 import type { AgentHistoryQuery } from '../agent-ours/correspondence.js';
 import { controlRequest } from '../session/control.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt } from '../session/conversation-types.js';
@@ -44,6 +45,11 @@ export interface RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    /** The newest visible events (or those before `before`), read backwards from the ledger. */
+    conversationTail?(request: {
+        before?: string;
+        limit?: number;
+    }): Promise<ConversationTailPage>;
     submitPromptV2?(request: {
         commandId: string;
         text: string;
@@ -94,6 +100,10 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    conversationTail(request?: {
+        before?: string;
+        limit?: number;
+    }): Promise<ConversationTailPage>;
     submitPromptV2(request: {
         commandId: string;
         text: string;

package/dist/application/session-control.js

@@ -1,4 +1,6 @@
-import { resumedConversationPage } from './conversation-history.js';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { conversationTailPage, resumedConversationPage } from './conversation-history.js';
 import { controlRequest, followConversation } from '../session/control.js';
 import { FleetError, normalizeError } from './errors.js';
 const visibleEvents = (events) => events.filter(event => event.kind !== 'thought');
@@ -78,13 +80,44 @@ export class RoleSessionControlAdapter {
             return live;
         }
     }
+    async conversationTail(request = {}) {
+        const live = await this.call('conversation_page', { limit: 1 });
+        const snapshot = await this.snapshot();
+        let resumed;
+        if (snapshot.backend === 'acp' && snapshot.sessionId) {
+            try {
+                if ((await readFile(join(this.stateDir, '.acp-session-id'), 'utf8')).trim() === snapshot.sessionId)
+                    resumed = snapshot.sessionId;
+            }
+            catch { /* no resumed history: live generation only */ }
+        }
+        try {
+            return await conversationTailPage(this.stateDir, request, live.snapshot, resumed);
+        }
+        catch (error) {
+            throw new FleetError('invalid_request', error.message);
+        }
+    }
     async submitPromptV2(request) {
         if (!request.text.trim())
             throw new FleetError('invalid_request', 'text is required');
         if (Buffer.byteLength(request.text) > 32 * 1024)
             throw new FleetError('invalid_request', 'text exceeds 32 KiB');
+        // A prompt bound to a session generation (voice or attachments) is checked atomically by supervisors that
+        // support it. Older supervisors do not know that command and never answer, so check the generation here
+        // and submit an ordinary prompt; its command id keeps retries idempotent either way.
+        let command = 'submit_prompt_v2';
+        if (request.expectedSessionGeneration) {
+            if ((await this.describe()).features.includes('generation_bound_prompts'))
+                command = 'submit_voice_prompt';
+            else {
+                const live = await this.call('conversation_page', { limit: 1 });
+                if (live.snapshot?.sessionGeneration !== request.expectedSessionGeneration)
+                    throw new FleetError('stale_state', 'Agent session changed. Record a new voice message.');
+            }
+        }
         try {
-            return await this.call(request.expectedSessionGeneration ? 'submit_voice_prompt' : 'submit_prompt_v2', {
+            return await this.call(command, {
                 commandId: request.commandId, text: request.text, actor: request.actorBrowserSession,
                 source: request.source, expectedSessionGeneration: request.expectedSessionGeneration,
             });

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.22",
-  "buildId": "f5776b7613c5",
-  "commit": "769fba35bc2918e792c353d2234d0fe5e2a48f57",
+  "version": "1.2.0-nightly.23",
+  "buildId": "84a9c6c0a54c",
+  "commit": "75b0bebdb33a4ace4713015f7a7f49adc330f6e4",
   "dirty": true,
-  "builtAt": "2026-09-30T07:56:23.700Z",
+  "builtAt": "2026-09-30T10:20:51.847Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/session/control.js

@@ -242,6 +242,7 @@ export class RoleControlServer {
                                 'events_since', 'observer_follow', 'retained_range',
                                 ...(this.correspondence ? ['agent_correspondence'] : []),
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
+                                ...(this.session.submitPromptBrowser ? ['generation_bound_prompts'] : []),
                                 ...(this.session.capabilities?.steering ? ['steering'] : []),
                                 ...(this.session.capabilities?.permissions ? ['permissions'] : []),
                                 ...(this.session.capabilities?.messagePhases ? ['message_phases'] : []),

package/dist/web/server.js

@@ -624,13 +624,22 @@ export async function buildWebServer(services, boundary, options = {}) {
         const control = await services.session(request.params.id);
         if (!control.conversationPage)
             throw new FleetError('capability_unavailable', 'this role has no conversation ledger');
-        const page = await control.conversationPage({
-            after: request.query.after,
-            limit: request.query.limit ? Number(request.query.limit) : undefined,
-        });
+        const limit = request.query.limit ? Number(request.query.limit) : undefined;
+        // `latest` / `before` page backwards from the newest event; `after` pages forward for live updates.
+        const backward = request.query.latest === '1' || request.query.before !== undefined;
+        if (backward && request.query.after !== undefined)
+            throw new FleetError('invalid_request', 'after cannot be combined with latest or before');
+        if (backward && !control.conversationTail)
+            throw new FleetError('capability_unavailable', 'this role cannot page its conversation backwards');
         const role = await services.repository.get(request.params.id);
         const stateDir = role ? services.repository.stateDir(role) : undefined;
-        return { ...page, events: page.events.map(event => presentAttachmentEvent(stateDir, request.params.id, event)) };
+        const present = (event) => presentAttachmentEvent(stateDir, request.params.id, event);
+        if (backward) {
+            const page = await control.conversationTail({ before: request.query.before, limit });
+            return { ...page, events: page.events.map(present), context: page.context.map(present) };
+        }
+        const page = await control.conversationPage({ after: request.query.after, limit });
+        return { ...page, events: page.events.map(present) };
     });
     app.get('/api/v1/roles/:id/attachments/:attachmentId', async (request, reply) => {
         auth.authenticate(request);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.22",
+  "version": "1.2.0-nightly.23",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",