@ours.network/fleet 1.2.0-nightly.78 → 1.2.0-nightly.79

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

@@ -17,7 +17,7 @@ export interface ConversationTailPage extends ConversationPageView {
 export declare function conversationTailPage(stateDir: string, request: {
     before?: string;
     limit?: number;
-}, snapshot: ConversationPageView['snapshot'], resumedSessionId?: string): Promise<ConversationTailPage>;
+}, snapshot: ConversationPageView['snapshot'], resumedSessionId?: string, signal?: AbortSignal): 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

@@ -8,16 +8,19 @@ export function conversationEventVisible(event, sessionGeneration, resumedSessio
     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) {
+async function readLinesBackward(path, visit, signal) {
+    signal?.throwIfAborted();
     const file = await open(path, 'r');
     try {
         let position = (await file.stat()).size;
         let carry = Buffer.alloc(0);
         while (position > 0) {
+            signal?.throwIfAborted();
             const size = Math.min(256 * 1024, position);
             position -= size;
             const chunk = Buffer.alloc(size);
             await file.read(chunk, 0, size, position);
+            signal?.throwIfAborted();
             let buffer = Buffer.concat([chunk, carry]);
             let end = buffer.length;
             for (let i = buffer.length - 1; i >= 0; i--) {
@@ -55,7 +58,8 @@ async function lastSeq(path) {
  * 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) {
+export async function conversationTailPage(stateDir, request, snapshot, resumedSessionId, signal) {
+    signal?.throwIfAborted();
     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');
@@ -68,12 +72,22 @@ export async function conversationTailPage(stateDir, request, snapshot, resumedS
     const events = [];
     let newest;
     let hasOlder = false;
-    const barrier = snapshot.ledgerBarrier;
-    const pending = new Set(snapshot.pendingPermissionIds);
+    const observation = snapshot;
+    const barrier = observation.ledgerBarrier;
+    // Current supervisors capture these sanitized inventories together with the
+    // ledger barrier. The browser uses them directly, including authoritative
+    // empty arrays. Looking for their old ledger events would scan the entire
+    // generation on every open. Legacy/incomplete snapshots still need context.
+    const complete = !snapshot.observationFailure && Number.isSafeInteger(barrier) && barrier >= 0
+        && Number.isSafeInteger(observation.stateRevision) && observation.stateRevision >= 0;
+    const needsCapabilities = !complete || !Array.isArray(observation.commands);
+    const pending = new Set(complete && Array.isArray(observation.pendingPermissions)
+        && snapshot.pendingPermissionIds.every(id => observation.pendingPermissions.some(permission => permission.permissionId === id))
+        ? [] : 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 wantsContext = () => before === Infinity && ((needsCapabilities && !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 => {
@@ -115,7 +129,7 @@ export async function conversationTailPage(stateDir, request, snapshot, resumedS
                     hasOlder = true;
             }
             return !hasOlder || wantsContext();
-        });
+        }, signal);
         if (!more)
             break;
     }

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

@@ -70,6 +70,7 @@ export interface RoleSessionControl {
     conversationTail?(request: {
         before?: string;
         limit?: number;
+        signal?: AbortSignal;
     }): Promise<ConversationTailPage>;
     submitPromptV2?(request: {
         commandId: string;
@@ -128,6 +129,7 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
     conversationTail(request?: {
         before?: string;
         limit?: number;
+        signal?: AbortSignal;
     }): Promise<ConversationTailPage>;
     submitPromptV2(request: {
         commandId: string;

package/dist/application/session-control.js

@@ -98,7 +98,9 @@ export class RoleSessionControlAdapter {
     async conversationTail(request = {}) {
         // A replacement while reading disk invalidates both the tail and its snapshot.
         for (let attempt = 0; attempt < 3; attempt++) {
+            request.signal?.throwIfAborted();
             const live = await this.call('conversation_page', { limit: 1 });
+            request.signal?.throwIfAborted();
             const snapshot = await this.snapshot();
             let resumed;
             if (snapshot.backend === 'acp' && snapshot.sessionId) {
@@ -110,12 +112,15 @@ export class RoleSessionControlAdapter {
             }
             let page;
             try {
-                page = await conversationTailPage(this.stateDir, request, live.snapshot, resumed);
+                page = await conversationTailPage(this.stateDir, request, live.snapshot, resumed, request.signal);
             }
             catch (error) {
+                request.signal?.throwIfAborted();
                 throw new FleetError('invalid_request', error.message);
             }
+            request.signal?.throwIfAborted();
             const check = await this.call('conversation_page', { limit: 1 });
+            request.signal?.throwIfAborted();
             if (check.snapshot.sessionGeneration === live.snapshot.sessionGeneration)
                 return page;
         }

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.78",
-  "buildId": "b2ec2cc5b628",
-  "commit": "42ac52e4fadbfe48faac20ac2518d7280947c981",
+  "version": "1.2.0-nightly.79",
+  "buildId": "ed6b63d22064",
+  "commit": "62a21f66895ff79cd5e5ea190febcfc59611e946",
   "dirty": true,
-  "builtAt": "2026-10-19T21:24:11.994Z",
+  "builtAt": "2026-10-19T21:53:54.074Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

package/dist/session/conversation-store.js

@@ -504,6 +504,13 @@ export class ConversationEventStore {
             return this.tail.filter(event => event.seq > after).slice(0, limit);
         const events = [];
         for (const segment of this.segments) {
+            // Recovery/append already indexed these single-writer segments. A page
+            // after a resumed generation's floor must not reread every older segment
+            // merely because the requested cursor is outside the memory tail.
+            // Degraded/unknown ranges retain the conservative recovery read path.
+            const range = this.segmentRanges.get(segment);
+            if (!this._degraded && range && !range.damaged && range.last !== undefined && range.last <= after)
+                continue;
             for (const event of this.readSegment(segment)) {
                 if (event.seq <= after)
                     continue;

package/dist/web/server.js

@@ -925,7 +925,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             limit: request.query.limit ? Number(request.query.limit) : undefined,
         });
     });
-    app.get('/api/v1/roles/:id/conversation', async (request) => {
+    app.get('/api/v1/roles/:id/conversation', async (request, reply) => {
         auth.authenticate(request);
         const control = await services.session(request.params.id);
         if (!control.conversationPage)
@@ -941,8 +941,21 @@ export async function buildWebServer(services, boundary, options = {}) {
         const stateDir = role ? services.repository.stateDir(role) : undefined;
         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 owner = new AbortController();
+            const cancel = () => owner.abort();
+            request.raw.once('aborted', cancel);
+            reply.raw.once('close', cancel);
+            if (request.raw.aborted || reply.raw.destroyed)
+                cancel();
+            try {
+                const page = await control.conversationTail({ before: request.query.before, limit, signal: owner.signal });
+                owner.signal.throwIfAborted();
+                return { ...page, events: page.events.map(present), context: page.context.map(present) };
+            }
+            finally {
+                request.raw.off('aborted', cancel);
+                reply.raw.off('close', cancel);
+            }
         }
         const page = await control.conversationPage({ after: request.query.after, limit });
         return { ...page, events: page.events.map(present) };

package/docs/conversation-stream.md

@@ -1,5 +1,25 @@
 # Conversation event stream (wire version 1)
 
+Initial `conversation?latest=1&limit=200` history uses the captured command and
+pending-permission inventories when the supervisor supplies a complete observation
+snapshot with its revision and ledger barrier. Empty inventories are authoritative.
+This avoids scanning the current generation for old context events after the
+latest page is full. Legacy, failed or incomplete captures retain ledger context
+recovery. Generation checks, resumed-session filtering and event cursors still apply.
+The private snapshot checks also use the store's recovered/appended segment ranges
+to skip healthy segments ending at or before their cursor. A retained prior
+generation therefore does not require rereading its whole prefix merely because
+the current-generation cursor is outside the in-memory tail. Degraded stores and
+unknown or damaged ranges retain conservative reads.
+Older pages can scan intervening newer ledger segments; the event count alone is
+not a disk-read byte bound.
+
+Disconnecting a latest/before HTTP history request cancels its disk tail reader
+at asynchronous read boundaries and prevents further orchestration or publication.
+An already admitted private-control RPC retains its existing timeout; disconnect
+does not interrupt the agent or its work. Forward-history reads and passive SSE
+retain their separate lifetimes.
+
 `GET /api/v1/roles/:id/conversation/events?expectedGeneration=GENERATION&after=CURSOR`
 uses the existing Fleet route boundary, including `/fleet/api/v1/...` through the
 prefix gateway. Use authenticated `fetch`, then read the response body. Cookies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.78",
+  "version": "1.2.0-nightly.79",
   "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",