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

package/dist/application/resource-observer.d.ts

@@ -13,6 +13,9 @@ export interface FleetResourceScope {
     roots?: string[];
     /** Overrides full Fleet discovery for narrow owners such as task delivery. */
     paths?: string[];
+    /** Path routing precedes a coalesced committed callback. Undefined means
+     * unknown/recovered coverage and requires conservative discovery. */
+    onInvalidated?: (path: string | undefined) => void;
     watch?: (path: string, listener: (event: string, filename: string | null) => void) => Pick<FSWatcher, 'on' | 'close'>;
 }
 /** Only call after durable persistence succeeds. Observers cannot fail a commit. */

package/dist/application/resource-observer.js

@@ -231,6 +231,7 @@ export function observeFleetResources(scope, onCommitted, signal) {
                 return;
             }
             state = { ...state, position: state.position + 1, health: 'healthy' };
+            scope.onInvalidated?.(undefined);
             // Reinstallation precedes one checkpoint recovery pass; later work is
             // event driven again. Degraded retries inspect directory metadata only.
             onCommitted({ ...state });
@@ -240,6 +241,7 @@ export function observeFleetResources(scope, onCommitted, signal) {
     const wake = (path) => {
         if (disposed || state.health !== 'healthy')
             return;
+        scope.onInvalidated?.(path);
         state = { ...state, position: state.position + 1 };
         for (const cursor of cursors)
             if (path === undefined || cursor.accepts(path))
@@ -283,6 +285,7 @@ export function observeFleetResources(scope, onCommitted, signal) {
             if (!added)
                 return;
             state = { ...state, position: state.position + 1 };
+            scope.onInvalidated?.(undefined);
             for (const cursor of cursors)
                 cursor.position = state.position;
         }

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.79",
-  "buildId": "ed6b63d22064",
-  "commit": "62a21f66895ff79cd5e5ea190febcfc59611e946",
+  "version": "1.2.0-nightly.80",
+  "buildId": "6177cc5cdd30",
+  "commit": "8e7ff4b04a6f6bf26e2de2710d18f9b5f0994657",
   "dirty": true,
-  "builtAt": "2026-10-19T21:53:54.074Z",
+  "builtAt": "2026-10-19T22:26:47.749Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

package/dist/notifications/fleet-producer.d.ts

@@ -10,12 +10,21 @@ export declare class FleetNotificationProducer {
     private readonly queues;
     private readonly observation;
     private continuation?;
+    private continuationAt;
+    private readonly dirty;
+    private readonly retryAt;
+    private discoveryNeeded;
+    private taskRoles?;
     private stopped;
     private readonly existing;
     private cleanup?;
     constructor(roots: string[], stateDir: string, config: ProducerConfig, warn?: (line: string) => void);
     private names;
+    private segments;
     poll(): void;
+    private accept;
+    private flush;
+    private scanRole;
     private resume;
     drain(): Promise<void>;
     close(): Promise<void>;

package/dist/notifications/fleet-producer.js

@@ -2,9 +2,12 @@ import { observeFleetResources } from '../application/resource-observer.js';
 import { roomsDir } from '../rooms-tasks/room-state.js';
 import { cleanupDir, drainNotificationTargetCleanup, notificationAgentId, hasPendingNotificationTargetCleanup } from './target-cleanup.js';
 import { closeSync, existsSync, lstatSync, openSync, readSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, join, relative, resolve, sep } from 'node:path';
 import { createHash } from 'node:crypto';
 import { NotificationOutbox } from './outbox.js';
+const BATCH_BYTES = 256 * 1024;
+const TURN_ROLES = 4, TURN_MS = 8;
+const RUNTIME_FILES = new Set(['.monitor-status', '.monitor-state.json', '.notify-cursor', '.session-events.jsonl', '.session-events.jsonl.1', '.subscription-usage.json']);
 /** Unlike a UI inventory, unread classification must not treat unreadable records as absence. */
 function taskRoleAssociations() {
     const dir = roomsDir(), result = new Map();
@@ -49,23 +52,53 @@ export class FleetNotificationProducer {
     queues = new Map();
     observation = new AbortController();
     continuation;
+    continuationAt = Infinity;
+    dirty = new Set();
+    retryAt = new Map();
+    discoveryNeeded = true;
+    taskRoles;
     stopped = false;
-    existing = new Set();
+    existing = new Map();
     cleanup;
     constructor(roots, stateDir, config, warn = () => { }) {
         this.roots = roots;
         this.stateDir = stateDir;
         this.config = config;
         this.warn = warn;
-        observeFleetResources({ retryWatchFailures: true, roots, paths: [...roots, roomsDir(), cleanupDir()] }, state => {
-            if (state.health === 'healthy')
-                this.poll();
-            else
+        let healthy = true;
+        observeFleetResources({ retryWatchFailures: true, roots, paths: [...roots, roomsDir(), cleanupDir()],
+            onInvalidated: path => this.accept(path) }, state => {
+            if (state.health !== 'healthy') {
+                healthy = false;
                 this.warn('Notification discovery observation unavailable; checkpoint retained');
+                return;
+            }
+            if (!healthy || this.dirty.size || this.discoveryNeeded) {
+                // Unknown wakes and watch reinstallation advance coverage without a
+                // pathname. Keep one conservative discovery pass for those barriers.
+                if (!healthy)
+                    this.discoveryNeeded = true;
+                healthy = true;
+                this.resume();
+            }
         }, this.observation.signal);
+        // Freeze startup history boundaries before deferring any role's content
+        // work. Later appends/segments must not become part of the ignored history.
+        // This pass reads directory/file metadata only, never ledger contents.
         for (const root of roots)
-            for (const name of this.names(root))
-                this.existing.add(join(root, name));
+            for (const name of this.names(root)) {
+                const roleDir = join(root, name), dir = join(roleDir, '.conversation');
+                try {
+                    if (!existsSync(dir) || lstatSync(dir).isSymbolicLink())
+                        continue;
+                    const segment = this.segments(dir).at(-1);
+                    if (segment)
+                        this.existing.set(roleDir, { segment, offset: statSync(join(dir, segment)).size, prompts: [] });
+                }
+                catch {
+                    this.existing.set(roleDir, null);
+                }
+            }
         this.poll();
     }
     names(root) {
@@ -76,7 +109,41 @@ export class FleetNotificationProducer {
             return [];
         }
     }
+    segments(dir) {
+        return readdirSync(dir).filter(n => /^events-\d{6}\.jsonl$/.test(n) && !lstatSync(join(dir, n)).isSymbolicLink()).sort();
+    }
     poll() {
+        if (this.stopped)
+            return;
+        this.discoveryNeeded = true;
+        this.flush();
+    }
+    accept(path) {
+        if (path === undefined) {
+            this.discoveryNeeded = true;
+            return true;
+        }
+        for (const root of this.roots) {
+            const local = relative(resolve(root), path), parts = local.split(sep);
+            if (local === '..' || local.startsWith('..' + sep))
+                continue;
+            if (parts.length === 2 && RUNTIME_FILES.has(parts[1]))
+                return false;
+            if (parts.length >= 2 && parts[1] === '.conversation') {
+                if (parts.length <= 3) {
+                    this.dirty.add(join(root, parts[0]));
+                    return true;
+                }
+            }
+            // Role replacement, unknown paths and metadata retain discovery. Room
+            // association and target-cleanup paths take the same conservative route.
+            this.discoveryNeeded = true;
+            return true;
+        }
+        this.discoveryNeeded = true;
+        return true;
+    }
+    flush() {
         if (this.stopped)
             return;
         this.cleanup ??= drainNotificationTargetCleanup(this.config, undefined, undefined, { beforeDelete: async (target) => {
@@ -122,114 +189,161 @@ export class FleetNotificationProducer {
             }
             catch { }
         });
-        let taskRoles;
-        try {
-            taskRoles = taskRoleAssociations();
+        if (this.discoveryNeeded) {
+            this.discoveryNeeded = false;
+            try {
+                this.taskRoles = taskRoleAssociations();
+            }
+            catch {
+                this.taskRoles = undefined;
+                this.warn('Notification task association unavailable; delivering unclassified events');
+            }
+            for (const root of this.roots)
+                for (const name of this.names(root))
+                    this.dirty.add(join(root, name));
         }
-        catch {
-            this.warn('Notification task association unavailable; delivering unclassified events');
+        // A turn reads at most four 256KiB batches (1MiB). The time bound is checked
+        // between roles; a synchronous filesystem operation cannot be preempted.
+        const started = performance.now();
+        let roles = 0;
+        for (const roleDir of this.dirty) {
+            if (roles >= TURN_ROLES || (roles && performance.now() - started >= TURN_MS))
+                break;
+            if ((this.retryAt.get(roleDir) ?? 0) > Date.now())
+                continue;
+            this.dirty.delete(roleDir);
+            this.retryAt.delete(roleDir);
+            roles++;
+            this.scanRole(roleDir, started + TURN_MS);
         }
-        for (const root of this.roots)
-            for (const roleId of this.names(root)) {
-                const roleDir = join(root, roleId), dir = join(roleDir, '.conversation');
-                try {
-                    if (!existsSync(dir) || lstatSync(dir).isSymbolicLink())
-                        continue;
-                    const segments = readdirSync(dir).filter(n => /^events-\d{6}\.jsonl$/.test(n) && !lstatSync(join(dir, n)).isSymbolicLink()).sort();
-                    if (!segments.length)
-                        continue;
-                    let outbox = this.queues.get(roleDir);
-                    if (!outbox) {
-                        const key = createHash('sha256').update(roleDir).digest('hex');
-                        outbox = new NotificationOutbox(join(this.stateDir, key + '.json'), this.config, async (value, eventId) => ({ eventId, title: `${roleId}: agent completed`, body: 'Your agent finished responding. Open the chat to view the result.',
-                            ...value, target: { kind: 'agent', agentId: roleId } }), this.warn);
-                        if (!outbox.checkpoint) {
-                            const segment = this.existing.has(roleDir) ? segments.at(-1) : segments[0];
-                            outbox.saveCheckpoint({ segment, offset: this.existing.has(roleDir) ? statSync(join(dir, segment)).size : 0, prompts: [] });
-                        }
-                        this.queues.set(roleDir, outbox);
-                    }
-                    const saved = outbox.checkpoint;
-                    const current = { ...saved, prompts: [...saved.prompts], messages: { ...saved.messages } };
-                    let index = segments.indexOf(current.segment);
-                    if (index < 0) {
-                        this.warn('Notification ledger segment unavailable; checkpoint retained');
-                        continue;
-                    }
-                    const file = join(dir, current.segment), size = statSync(file).size;
-                    if (size < current.offset) {
-                        this.warn('Notification ledger truncated; checkpoint retained');
-                        continue;
-                    }
-                    if (size === current.offset && index < segments.length - 1) {
-                        current.segment = segments[++index];
-                        current.offset = 0;
-                    }
-                    const fd = openSync(join(dir, current.segment), 'r'), buffer = Buffer.alloc(256 * 1024);
-                    let count;
-                    try {
-                        count = readSync(fd, buffer, 0, buffer.length, current.offset);
-                    }
-                    finally {
-                        closeSync(fd);
-                    }
-                    if (current.offset + count < statSync(join(dir, current.segment)).size || index < segments.length - 1)
-                        this.resume();
-                    let position = 0;
-                    while (position < count) {
-                        const end = buffer.indexOf(10, position);
-                        if (end < 0 || end >= count) {
-                            // Oversized model/media events are irrelevant to prompt/completion
-                            // correlation. Skip in bounded chunks; retain partial small lines.
-                            if (current.discarding || (position === 0 && count === buffer.length)) {
-                                current.offset += count - position;
-                                current.discarding = true;
-                                this.warn('Notification observer skipping oversized ledger record');
-                            }
-                            break;
-                        }
-                        if (current.discarding) {
-                            current.offset += end - position + 1;
-                            position = end + 1;
-                            current.discarding = false;
-                            continue;
-                        }
-                        const event = JSON.parse(buffer.subarray(position, end).toString('utf8'));
-                        if (event.schemaVersion !== 1 || event.roleId !== roleId)
-                            throw new Error('invalid ledger event');
-                        const prompt = `${event.sessionGeneration}:${event.promptId}`;
-                        if (event.kind === 'prompt.admitted' && event.promptId && ['browser', 'owner_admin_console', 'owner_channel'].includes(event.source ?? '')) {
-                            if (!current.prompts.includes(prompt))
-                                current.prompts.push(prompt);
-                        }
-                        if (['message.chunk', 'message.replace'].includes(event.kind) && event.promptId && event.messageId && current.prompts.includes(prompt))
-                            current.messages[prompt] = event.messageId;
-                        if (event.kind === 'turn.completed' && event.promptId && current.prompts.includes(prompt)) {
-                            if (!outbox.enqueue(`${roleId}:${event.sessionGeneration}:${event.seq}`, { ...(taskRoles ? { taskId: taskRoles.get(roleId) ?? null } : {}), anchor: { kind: 'fleet-message', messageId: current.messages[prompt] ?? event.promptId } })) {
-                                this.resume(1000);
-                                break;
-                            }
-                            current.prompts = current.prompts.filter(p => p !== prompt);
-                            delete current.messages[prompt];
-                        }
-                        current.offset += end - position + 1;
-                        position = end + 1;
+        if (this.dirty.size) {
+            let next = Infinity;
+            for (const roleDir of this.dirty)
+                next = Math.min(next, this.retryAt.get(roleDir) ?? Date.now());
+            this.resume(Math.max(0, next - Date.now()));
+        }
+    }
+    scanRole(roleDir, deadline) {
+        const roleId = basename(roleDir), dir = join(roleDir, '.conversation');
+        try {
+            if (!existsSync(dir) || lstatSync(dir).isSymbolicLink())
+                return;
+            const segments = this.segments(dir);
+            if (!segments.length)
+                return;
+            let outbox = this.queues.get(roleDir);
+            if (!outbox) {
+                const key = createHash('sha256').update(roleDir).digest('hex');
+                outbox = new NotificationOutbox(join(this.stateDir, key + '.json'), this.config, async (value, eventId) => ({ eventId, title: `${roleId}: agent completed`, body: 'Your agent finished responding. Open the chat to view the result.',
+                    ...value, target: { kind: 'agent', agentId: roleId } }), this.warn);
+                this.queues.set(roleDir, outbox);
+            }
+            if (!outbox.checkpoint) {
+                const initial = this.existing.get(roleDir);
+                if (initial === null)
+                    throw Error('Notification startup ledger boundary unavailable');
+                outbox.saveCheckpoint(initial ?? { segment: segments[0], offset: 0, prompts: [] });
+            }
+            const saved = outbox.checkpoint;
+            const current = { ...saved, prompts: [...saved.prompts], messages: { ...saved.messages } };
+            let index = segments.indexOf(current.segment);
+            if (index < 0) {
+                this.warn('Notification ledger segment unavailable; checkpoint retained');
+                return;
+            }
+            const file = join(dir, current.segment), size = statSync(file).size;
+            if (size < current.offset) {
+                this.warn('Notification ledger truncated; checkpoint retained');
+                return;
+            }
+            let remaining = size - current.offset;
+            while (remaining === 0 && index < segments.length - 1) {
+                current.segment = segments[++index];
+                current.offset = 0;
+                remaining = statSync(join(dir, current.segment)).size;
+            }
+            if (remaining === 0) {
+                if (current.segment !== saved.segment)
+                    outbox.saveCheckpoint(current);
+                return; // Latest EOF: no ledger open, allocation or read.
+            }
+            const fd = openSync(join(dir, current.segment), 'r'), buffer = Buffer.alloc(Math.min(BATCH_BYTES, remaining));
+            let count;
+            try {
+                count = readSync(fd, buffer, 0, buffer.length, current.offset);
+            }
+            finally {
+                closeSync(fd);
+            }
+            let position = 0, blocked = false;
+            while (position < count) {
+                const end = buffer.indexOf(10, position);
+                if (end < 0 || end >= count) {
+                    // Oversized model/media events are irrelevant to prompt/completion
+                    // correlation. Skip in bounded chunks; retain partial small lines.
+                    if (current.discarding || (position === 0 && count === BATCH_BYTES)) {
+                        current.offset += count - position;
+                        current.discarding = true;
+                        this.warn('Notification observer skipping oversized ledger record');
                     }
-                    if (current.segment !== saved.segment || current.offset !== saved.offset)
-                        outbox.saveCheckpoint(current);
+                    break;
                 }
-                catch {
-                    this.warn('Notification ledger admission pending; checkpoint will replay');
-                    // Retained, not-yet-admitted ledger work needs its own next-due wake;
-                    // the outbox sender can retry only events that were already admitted.
-                    this.resume(1000);
+                if (current.discarding) {
+                    current.offset += end - position + 1;
+                    position = end + 1;
+                    current.discarding = false;
+                    continue;
+                }
+                const event = JSON.parse(buffer.subarray(position, end).toString('utf8'));
+                if (event.schemaVersion !== 1 || event.roleId !== roleId)
+                    throw new Error('invalid ledger event');
+                const prompt = `${event.sessionGeneration}:${event.promptId}`;
+                if (event.kind === 'prompt.admitted' && event.promptId && ['browser', 'owner_admin_console', 'owner_channel'].includes(event.source ?? '')) {
+                    if (!current.prompts.includes(prompt))
+                        current.prompts.push(prompt);
                 }
+                if (['message.chunk', 'message.replace'].includes(event.kind) && event.promptId && event.messageId && current.prompts.includes(prompt))
+                    current.messages[prompt] = event.messageId;
+                if (event.kind === 'turn.completed' && event.promptId && current.prompts.includes(prompt)) {
+                    if (!outbox.enqueue(`${roleId}:${event.sessionGeneration}:${event.seq}`, { ...(this.taskRoles ? { taskId: this.taskRoles.get(roleId) ?? null } : {}), anchor: { kind: 'fleet-message', messageId: current.messages[prompt] ?? event.promptId } })) {
+                        blocked = true;
+                        break;
+                    }
+                    current.prompts = current.prompts.filter(p => p !== prompt);
+                    delete current.messages[prompt];
+                }
+                current.offset += end - position + 1;
+                position = end + 1;
+                if (performance.now() >= deadline)
+                    break;
             }
+            if (current.segment !== saved.segment || current.offset !== saved.offset)
+                outbox.saveCheckpoint(current);
+            if (blocked) {
+                this.retryAt.set(roleDir, Date.now() + 1000);
+                this.dirty.add(roleDir);
+            }
+            else if ((current.segment !== saved.segment || current.offset !== saved.offset)
+                && (current.offset < statSync(join(dir, current.segment)).size || index < segments.length - 1))
+                this.dirty.add(roleDir);
+        }
+        catch {
+            this.warn('Notification ledger admission pending; checkpoint will replay');
+            // Retained, not-yet-admitted ledger work needs its own next-due wake;
+            // the outbox sender can retry only events that were already admitted.
+            this.retryAt.set(roleDir, Date.now() + 1000);
+            this.dirty.add(roleDir);
+        }
     }
     resume(delay = 0) {
-        if (this.continuation || this.stopped)
+        if (this.stopped)
+            return;
+        const at = Date.now() + delay;
+        if (this.continuation && this.continuationAt <= at)
             return;
-        this.continuation = setTimeout(() => { this.continuation = undefined; this.poll(); }, delay);
+        clearTimeout(this.continuation);
+        this.continuationAt = at;
+        this.continuation = setTimeout(() => { this.continuation = undefined; this.continuationAt = Infinity; this.flush(); }, delay);
         this.continuation.unref();
     }
     async drain() { await Promise.all([...this.queues.values()].map(q => q.drain())); }

package/dist/web/fleet-config-service.d.ts

@@ -47,6 +47,9 @@ export declare class FleetConfigService {
     readonly path: string;
     private readonly preflight;
     private readonly beforeMutation?;
+    private validationInputs;
+    /** Cached during canonical reads; observer filtering must never parse YAML. */
+    resourceValidationInputs(): readonly string[];
     constructor(options?: FleetConfigServiceOptions);
     read(includeDefinitions?: boolean): ConfigReadResult;
     preview(baseRevision: string, input: unknown): Promise<ConfigPreviewResult>;

package/dist/web/fleet-config-service.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, } from 'node:fs';
-import { basename, dirname, extname, join } from 'node:path';
+import { basename, dirname, extname, join, resolve } from 'node:path';
 import { parse, stringify } from 'yaml';
 import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
 import { loadConfig, ROLE_NAME_RE, splitRootFor } from '../config.js';
@@ -18,6 +18,9 @@ export class FleetConfigService {
     path;
     preflight;
     beforeMutation;
+    validationInputs = [];
+    /** Cached during canonical reads; observer filtering must never parse YAML. */
+    resourceValidationInputs() { return this.validationInputs; }
     constructor(options = {}) {
         this.path = options.configPath ?? defaultConfigPath();
         this.preflight = options.preflight ?? (async () => emptyReport());
@@ -25,13 +28,24 @@ export class FleetConfigService {
     }
     read(includeDefinitions = false) {
         const sources = readSources(this.path);
+        let raw;
         try {
+            const manifest = parse(sources.documents.get(basename(sources.manifest)), { prettyErrors: false });
+            const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+            const vars = record(manifest.vars);
+            const expand = (value) => value.replace(/\$\{(\w+)\}/g, (match, key) => key in vars ? String(vars[key]) : match);
+            const invite = record(record(manifest.rooms).owner).public_invite_file;
+            const prompts = Object.values(record(manifest.watchdogs)).map(value => record(value).prompt_file);
+            // Record even invalid/missing references before validation, so repairing an
+            // already observed dependency can never retain a certified stale capture.
+            this.validationInputs = [...(typeof invite === 'string' ? [expand(expand(invite))] : []),
+                ...prompts.filter((value) => typeof value === 'string').map(expand)].map(value => resolve(value));
             loadConfig(this.path, { yamlMode: 'strict' });
+            raw = modelFrom(sources, includeDefinitions);
         }
         catch (error) {
             throw safeError(error, sourceSensitiveValues(sources));
         }
-        const raw = modelFrom(sources, includeDefinitions);
         const redacted = redactModel(raw);
         return {
             path: basename(this.path), exists: true, firstRun: false,

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

@@ -108,9 +108,10 @@ export declare class ResourceBindingError extends Error {
 export declare class FleetResourceViews {
     private scope;
     private project;
+    private configurationInputs;
     readonly producerGeneration: `${string}-${string}-${string}-${string}-${string}`;
     private connections;
-    constructor(scope: FleetResourceScope, project: (descriptor: ResourceDescriptor, signal: AbortSignal, owner: string) => Promise<unknown>);
+    constructor(scope: FleetResourceScope, project: (descriptor: ResourceDescriptor, signal: AbortSignal, owner: string) => Promise<unknown>, configurationInputs?: () => readonly string[]);
     open(response: ServerResponse, owner: string, authorized: () => boolean): {
         connectionId: `${string}-${string}-${string}-${string}-${string}`;
         close: () => void;

package/dist/web/resource-views.js

@@ -1,5 +1,7 @@
 import { relative, resolve, sep } from 'node:path';
-import { agentsRoot, tmpRoot, stateRoot } from '../paths.js';
+import { agentsRoot, tmpRoot, stateRoot, defaultConfigPath, fleetDDir } from '../paths.js';
+import { splitRootFor } from '../config.js';
+import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
 import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { observeFleetResources } from '../application/resource-observer.js';
@@ -184,11 +186,13 @@ export class ResourceBindingError extends Error {
 export class FleetResourceViews {
     scope;
     project;
+    configurationInputs;
     producerGeneration = randomUUID();
     connections = new Map();
-    constructor(scope, project) {
+    constructor(scope, project, configurationInputs = () => []) {
         this.scope = scope;
         this.project = project;
+        this.configurationInputs = configurationInputs;
     }
     open(response, owner, authorized) {
         const id = randomUUID(), controller = new AbortController();
@@ -348,6 +352,21 @@ export class FleetResourceViews {
         } });
     }
     affects(descriptor, path, structural = false) {
+        if (descriptor.resource === 'configuration') {
+            const manifest = resolve(this.scope.configPath ?? defaultConfigPath());
+            const root = resolve(splitRootFor(manifest)), changed = resolve(path);
+            const within = (candidate, parent) => {
+                const local = relative(parent, candidate);
+                return local === '' || (local !== '..' && !local.startsWith('..' + sep));
+            };
+            // Configuration and provenance read the manifest and split definitions;
+            // loadConfig also rejects legacy YAML files in the global fleet.d root.
+            // Ancestor replacement/unknown directory wakes remain conservative.
+            const legacy = resolve(fleetDDir());
+            return within(changed, root) || within(root, changed) || within(manifest, changed)
+                || within(changed, legacy) || within(legacy, changed)
+                || this.configurationInputs().some(input => within(resolve(input), changed));
+        }
         // An explicitly selected manifest may use any pathname, including one
         // otherwise reserved for an independent task receipt.
         if (this.scope.configPath && resolve(path) === resolve(this.scope.configPath))
@@ -389,10 +408,8 @@ export class FleetResourceViews {
                 return false;
             if (descriptor.resource === 'previews')
                 return (descriptor.ids ?? []).includes(parts[0]);
-            // Configuration/provenance reads no conversation data. Directory and
-            // roles intentionally remain conservative: live status includes activity.
-            if (descriptor.resource === 'configuration')
-                return false;
+            // Directory and roles intentionally remain conservative: live status
+            // includes activity. Configuration was classified by its inputs above.
         }
         return true;
     }
@@ -404,7 +421,14 @@ export class FleetResourceViews {
         if (view.running)
             return;
         view.running = true;
-        const task = connection.tail.then(() => this.refresh(connection, view));
+        const task = connection.tail.then(async () => {
+            // Resolved projection promises must not starve HTTP, timers or native
+            // watch delivery. Preserve serialization and coalesce this event batch.
+            await yieldToEventLoop();
+            if (!this.current(connection, view) || view.failed)
+                return;
+            await this.refresh(connection, view);
+        });
         connection.tail = task.catch(() => { });
         void task.finally(() => { view.running = false; if (view.dirty)
             this.schedule(connection, view); }).catch(connection.close);

package/dist/web/server.js

@@ -424,7 +424,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             }
         }
     };
-    const resources = new FleetResourceViews(services.resourceScope ?? {}, project);
+    const resources = new FleetResourceViews(services.resourceScope ?? {}, project, () => services.configuration?.resourceValidationInputs?.() ?? []);
     app.addHook('preClose', async () => resources.close());
     app.get('/api/v1/resource-events', async (request, reply) => {
         const browser = auth.authenticate(request);

package/package.json

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