@ours.network/fleet 1.2.0-nightly.82 → 1.2.0-nightly.84

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

@@ -25,9 +25,6 @@ export declare function resumedConversationPage(stateDir: string, request: {
 }, live: ConversationPageView, expectedSessionId: string): Promise<ConversationPageView>;
 /** Download authorization requires an actual published attachment, never an orphan copy. */
 export declare function conversationHasAttachment(stateDir: string, attachment: import('../file-delivery/types.js').DeliveredFile): Promise<boolean>;
-/** Passive, bounded last assistant text for directory previews. Never opens the
- * ledger writer/recovery path or acquires a session/controller. An incomplete
- * newest append is not committed yet; completed malformed records still fail. */
 export declare function conversationPreview(stateDir: string, signal: AbortSignal): Promise<{
     text: string;
     at: string;

package/dist/application/conversation-history.js

@@ -1,5 +1,5 @@
 import { createReadStream } from 'node:fs';
-import { open, readFile, readdir } from 'node:fs/promises';
+import { open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 const HISTORICAL_KINDS = ['file.attached', 'fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
@@ -40,8 +40,15 @@ async function readLinesBackward(path, visit, signal) {
         await file.close();
     }
 }
+// Rotated segments never change, so their last cursor is reused until the file itself changes.
+const lastSeqs = new Map();
 /** The last event cursor in a segment, read from its tail; undefined when none is readable. */
 async function lastSeq(path) {
+    const info = await stat(path).catch(() => undefined);
+    const key = info && `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}`;
+    const known = key ? lastSeqs.get(path) : undefined;
+    if (key && known?.key === key)
+        return known.seq;
     let seq;
     await readLinesBackward(path, line => { try {
         const value = Number(JSON.parse(line).seq);
@@ -51,6 +58,12 @@ async function lastSeq(path) {
         }
     }
     catch { } return true; });
+    if (key) {
+        lastSeqs.delete(path);
+        lastSeqs.set(path, { key, seq });
+        if (lastSeqs.size > 4096)
+            lastSeqs.delete(lastSeqs.keys().next().value);
+    }
     return seq;
 }
 /**
@@ -230,6 +243,60 @@ export async function conversationHasAttachment(stateDir, attachment) {
 /** Passive, bounded last assistant text for directory previews. Never opens the
  * ledger writer/recovery path or acquires a session/controller. An incomplete
  * newest append is not committed yet; completed malformed records still fail. */
+/** Bytes of a segment's tail a preview may consider, and the newest events it reads. */
+const PREVIEW_WINDOW_BYTES = 2 * 1024 * 1024;
+const PREVIEW_EVENTS = 200;
+/**
+ * Newest-first completed events from the last PREVIEW_WINDOW_BYTES of one
+ * segment, read backwards in chunks until `need` events are found. A record
+ * cut by the window start is not complete and is skipped. Only the newest
+ * segment can have an in-flight append; elsewhere a partial record fails.
+ */
+async function previewSegmentEvents(path, newest, need, signal) {
+    const events = [];
+    const file = await open(path, 'r');
+    try {
+        const size = (await file.stat()).size, floor = Math.max(0, size - PREVIEW_WINDOW_BYTES);
+        let position = size, carry = Buffer.alloc(0), trailing = true;
+        const take = (line) => {
+            const event = JSON.parse(line);
+            if (event.schemaVersion !== 1 || !Number.isSafeInteger(event.seq))
+                throw Error('preview ledger invalid');
+            events.push(event);
+        };
+        while (position > floor && events.length < need) {
+            signal.throwIfAborted();
+            const length = Math.min(64 * 1024, position - floor);
+            position -= length;
+            const chunk = Buffer.alloc(length);
+            await file.read(chunk, 0, length, position);
+            const buffer = Buffer.concat([chunk, carry]);
+            let end = buffer.length;
+            for (let i = buffer.length - 1; i >= 0 && events.length < need; i--) {
+                if (buffer[i] !== 10)
+                    continue;
+                if (trailing) {
+                    if (end > i + 1 && !newest)
+                        throw Error('preview ledger has partial record');
+                    trailing = false;
+                }
+                else
+                    take(buffer.toString('utf8', i + 1, end));
+                end = i;
+            }
+            carry = buffer.subarray(0, end);
+        }
+        if (trailing && position === floor && (!newest || floor > 0) && size > 0)
+            throw Error('preview ledger has partial record');
+        // At the file start the remaining bytes are the first complete record.
+        if (!trailing && floor === 0 && position === 0 && events.length < need)
+            take(carry.toString('utf8'));
+    }
+    finally {
+        await file.close();
+    }
+    return events;
+}
 export async function conversationPreview(stateDir, signal) {
     signal.throwIfAborted();
     const dir = join(stateDir, '.conversation');
@@ -245,30 +312,8 @@ export async function conversationPreview(stateDir, signal) {
     const events = [];
     for (const name of files) {
         signal.throwIfAborted();
-        const file = await open(join(dir, name), 'r');
-        try {
-            const size = (await file.stat()).size, length = Math.min(size, 2 * 1024 * 1024), buffer = Buffer.alloc(length);
-            await file.read(buffer, 0, length, size - length);
-            const completeEnd = buffer.lastIndexOf(10) + 1;
-            // Only the newest segment can have an in-flight append. If its tail
-            // fills the bounded window, we cannot establish the previous preview.
-            if (completeEnd < length && (name !== files[0] || (size > length && completeEnd === 0)))
-                throw Error('preview ledger has partial record');
-            const lines = buffer.toString('utf8', 0, completeEnd).split('\n');
-            lines.pop();
-            if (size > length)
-                lines.shift();
-            for (let i = lines.length - 1; i >= 0 && events.length < 200; i--) {
-                const event = JSON.parse(lines[i]);
-                if (event.schemaVersion !== 1 || !Number.isSafeInteger(event.seq))
-                    throw Error('preview ledger invalid');
-                events.push(event);
-            }
-        }
-        finally {
-            await file.close();
-        }
-        if (events.length >= 200)
+        events.push(...await previewSegmentEvents(join(dir, name), name === files[0], PREVIEW_EVENTS - events.length, signal));
+        if (events.length >= PREVIEW_EVENTS)
             break;
     }
     signal.throwIfAborted();

package/dist/application/role-repository.d.ts

@@ -16,6 +16,8 @@ export declare class RoleRepository {
     constructor(options?: RoleRepositoryOptions);
     list(strict?: boolean): Promise<RoleRecord[]>;
     get(id: string): Promise<RoleRecord | undefined>;
+    private scan;
+    private record;
     stateDir(record: RoleRecord): string | undefined;
     private detect;
 }

package/dist/application/role-repository.js

@@ -104,6 +104,20 @@ export class RoleRepository {
         this.options = options;
     }
     async list(strict = false) {
+        const scan = this.scan(strict);
+        const names = [...new Set([...scan.configuredByName.keys(), ...scan.permanent, ...scan.temporary])].sort();
+        return boundedMap(names, this.options.concurrency ?? 8, name => this.record(scan, name, strict));
+    }
+    // One role's record is built from its own state and probe; the other roles are never probed.
+    async get(id) {
+        if (!ROLE_NAME_RE.test(id))
+            return undefined;
+        const scan = this.scan(false);
+        if (!scan.configuredByName.has(id) && !scan.permanent.has(id) && !scan.temporary.has(id))
+            return undefined;
+        return this.record(scan, id, false);
+    }
+    scan(strict) {
         const permanentRoot = this.options.permanentRoot ?? agentsRoot();
         const temporaryRoot = this.options.temporaryRoot ?? tmpRoot();
         let configured = [];
@@ -116,60 +130,58 @@ export class RoleRepository {
                 throw error;
             configProblem = { code: 'config_invalid', severity: 'error', source: 'config', detail: error.message };
         }
-        const permanent = new Set(safeDirs(permanentRoot, strict));
-        const temporary = new Set(safeDirs(temporaryRoot, strict));
-        const configuredByName = new Map(configured.map(role => [role.name, role]));
-        const names = [...new Set([...configuredByName.keys(), ...permanent, ...temporary])].sort();
-        return boundedMap(names, this.options.concurrency ?? 8, async (name) => {
-            const config = configuredByName.get(name);
-            const inPermanent = permanent.has(name);
-            const inTemporary = temporary.has(name);
-            const problems = configProblem ? [configProblem] : [];
-            let tempRole;
-            let stateHealth = inPermanent || inTemporary ? 'present' : 'missing';
-            if (inTemporary) {
-                const read = snapshot(join(temporaryRoot, name, 'role.yaml'), name);
-                tempRole = read.role;
-                if (strict && read.problem)
-                    throw new Error('temporary role snapshot unavailable');
-                if (read.problem) {
-                    problems.push(read.problem);
-                    stateHealth = 'corrupt';
-                }
-            }
-            if (inPermanent && inTemporary)
-                problems.push({ code: 'duplicate_state', severity: 'error', detail: 'both permanent and temporary state exist' });
-            const intended = config?.session ?? tempRole?.session;
-            const detected = await this.detect(name, intended);
-            if (intended && detected !== 'none' && detected !== intended && detected !== 'ambiguous')
-                problems.push({
-                    code: 'backend_mismatch', severity: 'warning',
-                    detail: `configured ${intended}, detected ${detected}`,
-                });
-            const stateRef = inTemporary ? { lifetime: 'temporary' }
-                : inPermanent ? { lifetime: 'permanent' } : undefined;
-            const tempStateDir = inTemporary ? join(temporaryRoot, name) : undefined;
-            const taskId = !config && tempStateDir ? retainedTaskId(tempStateDir, name) : undefined;
-            return {
-                id: name,
-                lifetime: config ? 'permanent' : inTemporary ? 'temporary' : 'orphan',
-                configured: Boolean(config),
-                ...(taskId ? { taskId } : {}),
-                config: config ? view(config) : tempRole ? view(tempRole) : undefined,
-                stateRef,
-                stateHealth,
-                configuredBackend: intended,
-                detectedBackend: detected,
-                compatibility: { compatible: true },
-                problems,
-                lineage: tempStateDir ? readSpawnLineage(tempStateDir) : undefined,
-            };
-        });
+        return {
+            temporaryRoot, configProblem,
+            permanent: new Set(safeDirs(permanentRoot, strict)),
+            temporary: new Set(safeDirs(temporaryRoot, strict)),
+            configuredByName: new Map(configured.map(role => [role.name, role])),
+        };
     }
-    async get(id) {
-        if (!ROLE_NAME_RE.test(id))
-            return undefined;
-        return (await this.list()).find(role => role.id === id);
+    async record(scan, name, strict) {
+        const { temporaryRoot, configProblem } = scan;
+        const config = scan.configuredByName.get(name);
+        const inPermanent = scan.permanent.has(name);
+        const inTemporary = scan.temporary.has(name);
+        const problems = configProblem ? [configProblem] : [];
+        let tempRole;
+        let stateHealth = inPermanent || inTemporary ? 'present' : 'missing';
+        if (inTemporary) {
+            const read = snapshot(join(temporaryRoot, name, 'role.yaml'), name);
+            tempRole = read.role;
+            if (strict && read.problem)
+                throw new Error('temporary role snapshot unavailable');
+            if (read.problem) {
+                problems.push(read.problem);
+                stateHealth = 'corrupt';
+            }
+        }
+        if (inPermanent && inTemporary)
+            problems.push({ code: 'duplicate_state', severity: 'error', detail: 'both permanent and temporary state exist' });
+        const intended = config?.session ?? tempRole?.session;
+        const detected = await this.detect(name, intended);
+        if (intended && detected !== 'none' && detected !== intended && detected !== 'ambiguous')
+            problems.push({
+                code: 'backend_mismatch', severity: 'warning',
+                detail: `configured ${intended}, detected ${detected}`,
+            });
+        const stateRef = inTemporary ? { lifetime: 'temporary' }
+            : inPermanent ? { lifetime: 'permanent' } : undefined;
+        const tempStateDir = inTemporary ? join(temporaryRoot, name) : undefined;
+        const taskId = !config && tempStateDir ? retainedTaskId(tempStateDir, name) : undefined;
+        return {
+            id: name,
+            lifetime: config ? 'permanent' : inTemporary ? 'temporary' : 'orphan',
+            configured: Boolean(config),
+            ...(taskId ? { taskId } : {}),
+            config: config ? view(config) : tempRole ? view(tempRole) : undefined,
+            stateRef,
+            stateHealth,
+            configuredBackend: intended,
+            detectedBackend: detected,
+            compatibility: { compatible: true },
+            problems,
+            lineage: tempStateDir ? readSpawnLineage(tempStateDir) : undefined,
+        };
     }
     stateDir(record) {
         if (!record.stateRef)

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.82",
-  "buildId": "79b7bd25e769",
-  "commit": "0836a5d1d38495f31697ef62f286b9aa87442fc0",
+  "version": "1.2.0-nightly.84",
+  "buildId": "a63a3595510b",
+  "commit": "6db38803d52345eada7d87cc364a8a98d1144666",
   "dirty": true,
-  "builtAt": "2026-10-20T14:46:35.360Z",
+  "builtAt": "2026-10-20T19:57:42.666Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

package/dist/web/resource-views.d.ts

@@ -62,6 +62,8 @@ export interface ResourceWireFrame {
 export declare const RESOURCE_FRAME_BYTES: number;
 export declare const RESOURCE_PENDING_BYTES: number;
 export declare const RESOURCE_ASSEMBLY_BYTES: number;
+/** Minimum spacing of activity-only follow-up captures of one view. */
+export declare const ACTIVITY_CAPTURE_INTERVAL_MS = 1000;
 /** Lazily yield byte chunks so backpressure never queues an entire large record.
  * Base64 prevents splitting a Unicode scalar from corrupting JSON/SSE parsing. */
 export declare function resourceFrames(envelope: ResourceEnvelope): Generator<ResourceWireFrame>;
@@ -109,9 +111,10 @@ export declare class FleetResourceViews {
     private scope;
     private project;
     private configurationInputs;
+    private activityCaptureIntervalMs;
     readonly producerGeneration: `${string}-${string}-${string}-${string}-${string}`;
     private connections;
-    constructor(scope: FleetResourceScope, project: (descriptor: ResourceDescriptor, signal: AbortSignal, owner: string) => Promise<unknown>, configurationInputs?: () => readonly string[]);
+    constructor(scope: FleetResourceScope, project: (descriptor: ResourceDescriptor, signal: AbortSignal, owner: string) => Promise<unknown>, configurationInputs?: () => readonly string[], activityCaptureIntervalMs?: number);
     open(response: ServerResponse, owner: string, authorized: () => boolean): {
         connectionId: `${string}-${string}-${string}-${string}-${string}`;
         close: () => void;

package/dist/web/resource-views.js

@@ -23,6 +23,8 @@ export const RESOURCE_FRAME_BYTES = 512 * 1024;
 export const RESOURCE_PENDING_BYTES = 8 * 1024 * 1024;
 export const RESOURCE_ASSEMBLY_BYTES = 16 * 1024 * 1024;
 const CHUNK_BYTES = 256 * 1024;
+/** Minimum spacing of activity-only follow-up captures of one view. */
+export const ACTIVITY_CAPTURE_INTERVAL_MS = 1000;
 /** Lazily yield byte chunks so backpressure never queues an entire large record.
  * Base64 prevents splitting a Unicode scalar from corrupting JSON/SSE parsing. */
 export function* resourceFrames(envelope) {
@@ -187,12 +189,14 @@ export class FleetResourceViews {
     scope;
     project;
     configurationInputs;
+    activityCaptureIntervalMs;
     producerGeneration = randomUUID();
     connections = new Map();
-    constructor(scope, project, configurationInputs = () => []) {
+    constructor(scope, project, configurationInputs = () => [], activityCaptureIntervalMs = ACTIVITY_CAPTURE_INTERVAL_MS) {
         this.scope = scope;
         this.project = project;
         this.configurationInputs = configurationInputs;
+        this.activityCaptureIntervalMs = activityCaptureIntervalMs;
     }
     open(response, owner, authorized) {
         const id = randomUUID(), controller = new AbortController();
@@ -334,7 +338,7 @@ export class FleetResourceViews {
         return connection;
     }
     current(connection, view) { return !connection.controller.signal.aborted && !view.controller.signal.aborted && connection.views.get(view.descriptor.viewId) === view; }
-    retire(view) { view.controller.abort(); view.rejectInitial(new ResourceBindingError(409, 'resource binding retired')); }
+    retire(view) { clearTimeout(view.activityTimer); view.activityTimer = undefined; view.controller.abort(); view.rejectInitial(new ResourceBindingError(409, 'resource binding retired')); }
     emit(connection, view, kind, payload, source) {
         return connection.output.send({ protocolVersion: 1, producerGeneration: this.producerGeneration, viewId: view.descriptor.viewId, subscriptionEpoch: view.epoch, baselineId: view.baselineId, sequence: view.sequence + 1, revision: view.revision, kind, payload, ...(source ? { source } : {}) }, () => { view.sequence++; if (source || kind === 'ready')
             view.qualifiedAt = Date.now(); });
@@ -388,10 +392,10 @@ export class FleetResourceViews {
             return false;
         // Only classify known activity writes under the configured role roots.
         // Parent/unknown events and every other file retain full invalidation.
-        // The canonical web producer atomically replaces hashed checkpoint files.
-        // These delivery acknowledgements are not role/task/config membership;
-        // retain full wakes without requiring an outbox-quiet capture window.
-        if (structural && /^[a-f0-9]{64}\.json$/.test(relative(resolve(stateRoot(), 'web', 'notification-outboxes'), path)))
+        // The canonical web producer atomically replaces hashed checkpoint files,
+        // once per ledger advance of any role. No projection reads these delivery
+        // acknowledgements, so they neither fence a capture nor wake a follow-up.
+        if (/^[a-f0-9]{64}\.json$/.test(relative(resolve(stateRoot(), 'web', 'notification-outboxes'), path)))
             return false;
         for (const root of roots) {
             const parts = relative(resolve(root), path).split(sep);
@@ -421,9 +425,28 @@ export class FleetResourceViews {
         }
         return true;
     }
-    schedule(connection, view) {
+    schedule(connection, view, due = false) {
         if (!this.current(connection, view) || view.failed)
             return;
+        // Agent activity (ledger appends, status files) changes previews and status
+        // continuously while an agent works. Without a structural change since the
+        // latest capture began, coalesce those wakes into one trailing capture per
+        // interval instead of re-projecting every role after every append.
+        const wait = !due && view.captureSource !== view.source && view.capturedAt !== undefined
+            && view.captureSource.snapshot().position === view.capturedStructure
+            ? this.activityCaptureIntervalMs - (Date.now() - view.capturedAt) : 0;
+        if (wait > 0) {
+            view.scheduledPosition = view.source.snapshot().position;
+            view.dirty = true;
+            if (!view.running && !view.activityTimer) {
+                // The trailing capture runs when its timer fires, whatever the clock reads.
+                view.activityTimer = setTimeout(() => { view.activityTimer = undefined; this.schedule(connection, view, true); }, Math.min(wait, this.activityCaptureIntervalMs));
+                view.activityTimer.unref?.();
+            }
+            return;
+        }
+        clearTimeout(view.activityTimer);
+        view.activityTimer = undefined;
         view.scheduledPosition = view.source.snapshot().position;
         view.dirty = true;
         if (view.running)
@@ -446,6 +469,8 @@ export class FleetResourceViews {
             if (!view.dirty || !this.current(connection, view))
                 return;
             view.dirty = false;
+            view.capturedAt = Date.now();
+            view.capturedStructure = view.captureSource.snapshot().position;
             let payload, source;
             for (let attempt = 0; attempt < 3; attempt++) {
                 view.controller.signal.throwIfAborted();

package/package.json

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