@ours.network/fleet 1.2.0-nightly.70 → 1.2.0-nightly.72

package/dist/daemon-recovery.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { attachOursClient, } from '@ours.network/sdk/client';
+import { classifyIdentityPresence } from './monitor.js';
 import { readClientProfile } from './client-profile.js';
 import { replaceFileAtomically } from './atomic-file.js';
 export const DAEMON_RECOVERY_MAX_ATTEMPTS = 6;
@@ -41,7 +42,8 @@ function startupProgress(value) {
 /** Read generation and readiness through the selected gateway. Server paths are opaque. */
 export async function probeDaemonGeneration(fetch, env, deps = {}) {
     try {
-        return await probeSelectedDaemon(deps, readClientProfile(env));
+        const { identities: _identities, ...generation } = await probeSelectedDaemon(deps, readClientProfile(env));
+        return generation;
     }
     catch {
         return { state: 'unavailable', reason: 'CLIENT_GATEWAY_PROFILE_INVALID' };
@@ -56,7 +58,7 @@ async function probeSelectedDaemon(deps, profile) {
         const options = {
             endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
             credentialPath: profile.credentialPath,
-            sessionMode: 'external', leaseToken: randomUUID(), env: {},
+            sessionMode: 'external', leaseToken: randomUUID(), env: {}, requestSignal: deps.requestSignal,
         };
         client = await (deps.attachClient?.(options) ?? attachOursClient(options));
         const info = await client.version({ startup: true });
@@ -75,7 +77,7 @@ async function probeSelectedDaemon(deps, profile) {
             return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
         if (!identities.length)
             return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_NOT_READY' };
-        return { state: 'ready', generation: {
+        return { state: 'ready', identities, generation: {
                 bootId: progress.bootId, pid: progress.pid, startedAt: progress.startedAt, stateDir: info.stateDir,
             } };
     }
@@ -87,6 +89,118 @@ async function probeSelectedDaemon(deps, profile) {
         await client?.close().catch(() => undefined);
     }
 }
+const selectedHealthOwners = new Map();
+const unavailableHealth = (reason) => ({
+    generation: { state: 'unavailable', reason },
+});
+/** Retained runtime health, independent of browser delivery and stream readiness. */
+export function acquireSelectedDaemonHealth(env, deps = {}) {
+    let profile;
+    try {
+        profile = readClientProfile(env);
+    }
+    catch {
+        return {
+            sample: async () => unavailableHealth('CLIENT_GATEWAY_PROFILE_INVALID'),
+            presence: () => ({ state: 'unknown', detail: 'selected daemon unavailable' }),
+            release: () => { },
+        };
+    }
+    // Credentials are part of the selection boundary, not merely endpoint identity.
+    const key = JSON.stringify([profile.endpoint, profile.expectedInstanceId, profile.credentialPath]);
+    let owner = selectedHealthOwners.get(key);
+    if (!owner) {
+        let stopped = false;
+        let timer;
+        let current;
+        let nextProbeAt = 0;
+        let pending;
+        let cancelProbe;
+        const run = () => {
+            let client;
+            let closed = false;
+            let cancelled = false;
+            const request = new AbortController();
+            const close = async () => {
+                if (client && !closed) {
+                    closed = true;
+                    await client.close().catch(() => undefined);
+                }
+            };
+            let deadline;
+            const interrupted = new Promise(resolve => {
+                cancelProbe = () => {
+                    cancelled = true;
+                    request.abort();
+                    void close();
+                    resolve(unavailableHealth('DAEMON_SELECTED_PROBE_UNAVAILABLE'));
+                };
+                deadline = setTimeout(cancelProbe, 10_000);
+                deadline.unref?.();
+            });
+            const probe = probeSelectedDaemon({ ...deps, requestSignal: request.signal, attachClient: async (options) => {
+                    client = await (deps.attachClient?.(options) ?? attachOursClient(options));
+                    if (cancelled) {
+                        void close();
+                        throw new Error('health probe cancelled');
+                    }
+                    return { version: (...args) => client.version(...args),
+                        identities: () => client.identities(), close };
+                } }, profile).then(({ identities, ...generation }) => ({ generation, identities }));
+            pending = Promise.race([probe, interrupted]).then(snapshot => {
+                if (!stopped)
+                    current = snapshot;
+                return snapshot;
+            }).finally(() => {
+                if (deadline)
+                    clearTimeout(deadline);
+                cancelProbe = undefined;
+                pending = undefined;
+                if (!stopped) {
+                    nextProbeAt = Date.now() + 2_000;
+                    timer = setTimeout(() => { void run(); }, 2_000);
+                    timer.unref?.();
+                }
+            });
+            return pending;
+        };
+        owner = {
+            consumers: 0,
+            sample: () => {
+                if (pending)
+                    return pending;
+                if (current && Date.now() < nextProbeAt)
+                    return Promise.resolve(current);
+                // A delayed timer after process suspension cannot certify old absence.
+                if (timer)
+                    clearTimeout(timer);
+                return run();
+            },
+            stop: () => { stopped = true; if (timer)
+                clearTimeout(timer); cancelProbe?.(); },
+        };
+        selectedHealthOwners.set(key, owner);
+        void run();
+    }
+    const retained = owner;
+    retained.consumers++;
+    let released = false;
+    return {
+        sample: () => released ? Promise.resolve(unavailableHealth('HEALTH_OWNER_RELEASED')) : retained.sample(),
+        presence: (name, snapshot) => snapshot.generation.state === 'ready'
+            ? classifyIdentityPresence(name, snapshot.identities)
+            : { state: 'unknown', detail: 'selected daemon unavailable' },
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            if (--retained.consumers === 0) {
+                retained.stop();
+                selectedHealthOwners.delete(key);
+            }
+        },
+    };
+}
 export class DaemonGenerationObserver {
     current;
     unavailable = false;

package/dist/monitor.d.ts

@@ -108,6 +108,7 @@ export type IdentityPresence = {
  * valid but missing identity, which made a closed temp identity look healthy.
  */
 export declare function probeIdentityPresence(name: string, fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: IdentityProbeDeps): Promise<IdentityPresence>;
+export declare function classifyIdentityPresence(name: string, identities: unknown): IdentityPresence;
 /** Keep only the events whose type the role asked to wake on. */
 export declare function filterEvents(events: NotifyEvent[], wakeSources: string[]): NotifyEvent[];
 /**

package/dist/monitor.js

@@ -65,7 +65,7 @@ export async function probeIdentityPresence(name, fetch, env, deps = {}) {
         await client?.close().catch(() => undefined);
     }
 }
-function classifyIdentityPresence(name, identities) {
+export function classifyIdentityPresence(name, identities) {
     if (!Array.isArray(identities))
         return { state: 'unknown', detail: 'identity index response is malformed' };
     // A healthy daemon normally has at least its Human identity. During daemon

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

@@ -8,12 +8,15 @@ export declare class FleetNotificationProducer {
     private readonly config;
     private readonly warn;
     private readonly queues;
-    private readonly timer;
+    private readonly observation;
+    private continuation?;
+    private stopped;
     private readonly existing;
     private cleanup?;
     constructor(roots: string[], stateDir: string, config: ProducerConfig, warn?: (line: string) => void);
     private names;
     poll(): void;
+    private resume;
     drain(): Promise<void>;
     close(): Promise<void>;
 }

package/dist/notifications/fleet-producer.js

@@ -1,5 +1,6 @@
+import { observeFleetResources } from '../application/resource-observer.js';
 import { roomsDir } from '../rooms-tasks/room-state.js';
-import { drainNotificationTargetCleanup, notificationAgentId } from './target-cleanup.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 { createHash } from 'node:crypto';
@@ -46,7 +47,9 @@ export class FleetNotificationProducer {
     config;
     warn;
     queues = new Map();
-    timer;
+    observation = new AbortController();
+    continuation;
+    stopped = false;
     existing = new Set();
     cleanup;
     constructor(roots, stateDir, config, warn = () => { }) {
@@ -54,12 +57,16 @@ export class FleetNotificationProducer {
         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
+                this.warn('Notification discovery observation unavailable; checkpoint retained');
+        }, this.observation.signal);
         for (const root of roots)
             for (const name of this.names(root))
                 this.existing.add(join(root, name));
         this.poll();
-        this.timer = setInterval(() => this.poll(), 1000);
-        this.timer.unref();
     }
     names(root) {
         try {
@@ -70,8 +77,10 @@ export class FleetNotificationProducer {
         }
     }
     poll() {
-        this.cleanup ??= drainNotificationTargetCleanup(this.config, undefined, undefined, { beforeDelete: async (url) => {
-                const name = notificationAgentId(url);
+        if (this.stopped)
+            return;
+        this.cleanup ??= drainNotificationTargetCleanup(this.config, undefined, undefined, { beforeDelete: async (target) => {
+                const name = notificationAgentId(target);
                 if (!name || !/^[A-Za-z0-9_-]+$/.test(name))
                     return false;
                 // A recreated or retained role still has a valid target. Filesystem errors cannot prove removal.
@@ -105,7 +114,14 @@ export class FleetNotificationProducer {
                     }
                 }
                 return true;
-            } }).catch(() => { }).finally(() => { this.cleanup = undefined; });
+            } }).catch(() => { }).finally(() => {
+            this.cleanup = undefined;
+            try {
+                if (hasPendingNotificationTargetCleanup())
+                    this.resume(3000);
+            }
+            catch { }
+        });
         let taskRoles;
         try {
             taskRoles = taskRoleAssociations();
@@ -126,7 +142,7 @@ export class FleetNotificationProducer {
                     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.',
-                            url: `/fleet/chats/agents/${encodeURIComponent(roleId)}`, ...value }), this.warn);
+                            ...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: [] });
@@ -157,6 +173,8 @@ export class FleetNotificationProducer {
                     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);
@@ -187,8 +205,10 @@ export class FleetNotificationProducer {
                         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 } : {}), url: `/fleet/chats/agents/${encodeURIComponent(roleId)}#fleet-message-${encodeURIComponent(current.messages[prompt] ?? event.promptId)}` }))
+                            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];
                         }
@@ -200,9 +220,18 @@ export class FleetNotificationProducer {
                 }
                 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);
                 }
             }
     }
+    resume(delay = 0) {
+        if (this.continuation || this.stopped)
+            return;
+        this.continuation = setTimeout(() => { this.continuation = undefined; this.poll(); }, delay);
+        this.continuation.unref();
+    }
     async drain() { await Promise.all([...this.queues.values()].map(q => q.drain())); }
-    async close() { clearInterval(this.timer); await this.cleanup; await Promise.all([...this.queues.values()].map(q => q.close())); }
+    async close() { this.stopped = true; this.observation.abort(); clearTimeout(this.continuation); await this.cleanup; await Promise.all([...this.queues.values()].map(q => q.close())); }
 }

package/dist/notifications/outbox.d.ts

@@ -1,10 +1,23 @@
+export type NotificationTarget = {
+    kind: 'agent';
+    agentId: string;
+} | {
+    kind: 'task' | 'task-deleted';
+    taskId: string;
+};
 export interface NotificationInput {
     eventId: string;
     title: string;
     body: string;
-    url: string;
+    target: NotificationTarget;
+    anchor?: {
+        kind: 'fleet-message';
+        messageId: string;
+    };
     taskId?: string | null;
 }
+/** Only the closed typed contract is sent; any other payload is never sent or converted. */
+export declare function isNotificationInput(value: unknown): value is NotificationInput;
 export interface ProducerConfig {
     /** Service base URL. With a gateway credential it is the server gateway's notifications route. */
     origin: string;

package/dist/notifications/outbox.js

@@ -2,6 +2,38 @@ import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, re
 import { dirname, join } from 'node:path';
 import { readPrivateFile } from '@ours.network/sdk/connector';
 import { readClientProfile } from '../client-profile.js';
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const closed = (value, keys) => Object.keys(value).every(key => keys.includes(key));
+const domainId = (id) => typeof id === 'string' && /^[A-Za-z0-9_-]{1,120}$/.test(id);
+const text = (value, max) => typeof value === 'string' && !!value.trim() && value.length <= max;
+/** Only the closed typed contract is sent; any other payload is never sent or converted. */
+export function isNotificationInput(value) {
+    if (!object(value) || !closed(value, ['eventId', 'title', 'body', 'target', 'anchor', 'taskId'])
+        || !text(value.eventId, 512) || !text(value.title, 160) || !text(value.body, 512) || !object(value.target))
+        return false;
+    const target = value.target;
+    if (target.kind === 'agent') {
+        if (!closed(target, ['kind', 'agentId']) || !domainId(target.agentId))
+            return false;
+    }
+    else if (target.kind === 'task' || target.kind === 'task-deleted') {
+        if (!closed(target, ['kind', 'taskId']) || !domainId(target.taskId) || (value.taskId !== undefined && value.taskId !== target.taskId))
+            return false;
+    }
+    else
+        return false;
+    if (value.taskId !== undefined && value.taskId !== null && !domainId(value.taskId))
+        return false;
+    return value.anchor === undefined || (target.kind === 'agent' && object(value.anchor)
+        && closed(value.anchor, ['kind', 'messageId']) && value.anchor.kind === 'fleet-message' && text(value.anchor.messageId, 1024) && !/[\x00-\x1f\x7f]/.test(value.anchor.messageId));
+}
+const has = (entry, key) => Object.hasOwn(entry, key);
+// An entry is sent only when it is an object with a string ID and its frozen payload is the closed
+// typed contract or, with no payload field at all, it carries the current version marker. Anything
+// else, including null or scalar entries, is never read further, projected, sent or changed.
+const supported = (entry) => object(entry) && typeof entry.id === 'string' && !has(entry, 'operation')
+    && (has(entry, 'payload') ? isNotificationInput(entry.payload) : entry.targetVersion === 1);
+const same = (id) => (entry) => supported(entry) && entry.id === id;
 function defaultProfile() {
     try {
         return readClientProfile();
@@ -75,11 +107,12 @@ export class NotificationOutbox {
         this.warn = warn;
         mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
         const saved = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : { entries: [] };
-        this.entries = Array.isArray(saved) ? saved : saved.entries;
+        // Only the current state shape is read; anything else is refused and left unchanged on disk.
+        if (!saved || typeof saved !== 'object' || Array.isArray(saved) || !Array.isArray(saved.entries))
+            throw new Error('Unsupported notification outbox state');
+        this.entries = saved.entries;
         this.cursor = saved.cursor;
         this.checkpoint = saved.checkpoint;
-        if (!Array.isArray(this.entries))
-            throw new Error('invalid notification outbox');
         this.timer = setInterval(() => { void this.drain(); }, 3000);
         this.timer.unref();
     }
@@ -109,14 +142,14 @@ export class NotificationOutbox {
     enqueue(id, value, cursor = this.cursor) {
         if (this.retired)
             return false;
-        if (this.entries.some(e => e.id === id)) {
+        if (this.entries.some(same(id))) {
             if (cursor !== this.cursor)
                 this.advance(cursor);
             return true;
         }
-        if (this.entries.length >= 2000)
+        if (this.entries.filter(supported).length >= 2000)
             return false;
-        this.persist([...this.entries, { id, value }], cursor);
+        this.persist([...this.entries, { id, value, targetVersion: 1 }], cursor);
         return true;
     }
     drain() {
@@ -125,15 +158,23 @@ export class NotificationOutbox {
         return this.running ??= this.drainOnce().finally(() => { this.running = undefined; });
     }
     async drainOnce() {
-        for (const entry of [...this.entries].slice(0, 32)) {
+        let attempts = 0;
+        for (const entry of [...this.entries]) {
+            if (!supported(entry))
+                continue;
+            if (attempts >= 32)
+                break;
             if (this.retired)
                 break;
             try {
                 const value = entry.payload ?? await this.project(entry.value, entry.id);
+                if (!isNotificationInput(value))
+                    continue;
+                attempts++;
                 // Freeze the canonical projection before any network attempt. A crash
                 // after service acceptance must replay the identical dedupe payload.
                 if (!entry.payload)
-                    this.persist(this.entries.map(e => e.id === entry.id ? { ...e, payload: value } : e));
+                    this.persist(this.entries.map(e => same(entry.id)(e) ? { ...e, payload: value } : e));
                 const response = await fetch(this.config.origin + '/api/v1/send', {
                     method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
                     headers: { ...(this.config.gatewayCredential
@@ -144,7 +185,7 @@ export class NotificationOutbox {
                 await response.body?.cancel();
                 if (!response.ok)
                     throw new Error('notification service rejected event');
-                this.persist(this.entries.filter(e => e.id !== entry.id));
+                this.persist(this.entries.filter(e => !same(entry.id)(e)));
             }
             catch {
                 this.warn('Notification producer delivery pending; retrying from durable outbox');
@@ -153,6 +194,6 @@ export class NotificationOutbox {
         }
     }
     /** Wait for the current send before clearing queued sends and retiring its target. */
-    async retire() { this.retired = true; clearInterval(this.timer); await this.running; this.persist([]); }
+    async retire() { this.retired = true; clearInterval(this.timer); await this.running; this.persist(this.entries.filter(entry => !supported(entry))); }
     async close() { clearInterval(this.timer); await this.running; }
 }

package/dist/notifications/target-cleanup.d.ts

@@ -1,10 +1,16 @@
 import { type ProducerConfig } from './outbox.js';
-/** Only the canonical agent namespace can authorize role-target cleanup. */
-export declare function notificationAgentId(path: string): string | null;
+export declare const cleanupDir: () => string;
+export type AgentTarget = {
+    kind: 'agent';
+    agentId: string;
+};
+/** Only a closed agent identity authorizes this producer's role-target cleanup. */
+export declare function notificationAgentId(target: unknown): string | null;
+export declare function hasPendingNotificationTargetCleanup(dir?: string): boolean;
 /** Queue only after the owning lifecycle has established deletion, never on a failed inventory read. */
-export declare function retireNotificationTarget(url: string, config?: ProducerConfig | undefined, dir?: string, request?: typeof fetch): Promise<void>;
+export declare function retireNotificationTarget(target: AgentTarget, config?: ProducerConfig | undefined, dir?: string, request?: typeof fetch): Promise<void>;
 /** Persisted retries also run from the ordinary web notification producer after restart. */
 export declare function drainNotificationTargetCleanup(config: ProducerConfig, dir?: string, request?: typeof fetch, options?: {
     retain?: boolean;
-    beforeDelete?: (url: string) => Promise<boolean>;
+    beforeDelete?: (target: AgentTarget) => Promise<boolean>;
 }): Promise<void>;

package/dist/notifications/target-cleanup.js

@@ -4,31 +4,36 @@ import { join } from 'node:path';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
 import { producerConfig } from './outbox.js';
-const cleanupDir = () => join(stateRoot(), 'notifications', 'removed-targets');
-/** Only the canonical agent namespace can authorize role-target cleanup. */
-export function notificationAgentId(path) {
-    try {
-        if (typeof path !== 'string' || /[\\\x00-\x20]|%(?:2f|5c|00|0[ad])/i.test(path))
-            return null;
-        const match = /^\/fleet\/chats\/agents\/([^/?#]+)(?:[?#]|$)/.exec(path);
-        if (!match)
-            return null;
-        const url = new URL(path, 'https://ours.invalid');
-        if (['source', 'chat', 'task', 'detail'].some(key => url.searchParams.has(key)))
-            return null;
-        const id = decodeURIComponent(match[1]);
-        return /^[A-Za-z0-9_-]+$/.test(id) ? id : null;
-    }
-    catch {
+export const cleanupDir = () => join(stateRoot(), 'notifications', 'removed-targets');
+/** Only a closed agent identity authorizes this producer's role-target cleanup. */
+export function notificationAgentId(target) {
+    if (!target || typeof target !== 'object' || Array.isArray(target))
         return null;
-    }
+    const value = target;
+    return Object.keys(value).every(key => ['kind', 'agentId'].includes(key)) && value.kind === 'agent'
+        && typeof value.agentId === 'string' && /^[A-Za-z0-9_-]{1,120}$/.test(value.agentId) ? value.agentId : null;
+}
+export function hasPendingNotificationTargetCleanup(dir = cleanupDir()) {
+    if (!existsSync(dir))
+        return false;
+    return readdirSync(dir).filter(file => /^[a-f0-9]{64}\.json$/.test(file)).some(file => {
+        try {
+            const value = JSON.parse(readFileSync(join(dir, file), 'utf8'));
+            return !!value && typeof value === 'object' && Object.keys(value).length === 1 && !!notificationAgentId(value.target);
+        }
+        catch (error) {
+            return !(error instanceof SyntaxError);
+        }
+    });
 }
 /** Queue only after the owning lifecycle has established deletion, never on a failed inventory read. */
-export async function retireNotificationTarget(url, config = producerConfig(), dir = cleanupDir(), request = fetch) {
+export async function retireNotificationTarget(target, config = producerConfig(), dir = cleanupDir(), request = fetch) {
     if (!config)
         return;
+    if (!notificationAgentId(target))
+        throw new Error('Invalid notification target');
     mkdirSync(dir, { recursive: true, mode: 0o700 });
-    replaceFileAtomically(join(dir, createHash('sha256').update(url).digest('hex') + '.json'), JSON.stringify({ url }) + '\n', 0o600);
+    replaceFileAtomically(join(dir, createHash('sha256').update(JSON.stringify({ kind: 'agent', agentId: target.agentId })).digest('hex') + '.json'), JSON.stringify({ target }) + '\n', 0o600);
     await drainNotificationTargetCleanup(config, dir, request, { retain: true });
 }
 /** Persisted retries also run from the ordinary web notification producer after restart. */
@@ -39,12 +44,19 @@ export async function drainNotificationTargetCleanup(config, dir = cleanupDir(),
     for (const file of readdirSync(dir).filter(file => /^[a-f0-9]{64}\.json$/.test(file))) {
         if (attempts >= 32)
             break;
+        const path = join(dir, file);
+        let value;
+        try {
+            value = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).length !== 1 || !notificationAgentId(value.target))
+            continue;
         try {
-            const path = join(dir, file), value = JSON.parse(readFileSync(path, 'utf8'));
-            if (!notificationAgentId(value.url))
-                continue;
             attempts++;
-            if (options.beforeDelete && !(await options.beforeDelete(value.url))) {
+            if (options.beforeDelete && !(await options.beforeDelete(value.target))) {
                 rmSync(path, { force: true });
                 continue;
             }

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

@@ -6,13 +6,15 @@ export declare class TaskNotificationProducer {
     private readonly config;
     private readonly warn;
     private readonly request;
-    private readonly timer;
+    private timer?;
+    private dirty;
     private running?;
     private offset;
     private stopped;
     private readonly shutdown;
     constructor(config: ProducerConfig, warn?: (line: string) => void, request?: typeof fetch);
     drain(): Promise<void>;
+    private retry;
     private drainOnce;
     close(): Promise<void>;
 }

package/dist/notifications/task-producer.js

@@ -1,3 +1,5 @@
+import { observeFleetResources } from '../application/resource-observer.js';
+import { tasksDir } from '../rooms-tasks/task-state.js';
 import { acknowledgeTaskNotification, pendingTaskNotifications } from '../rooms-tasks/task-state.js';
 /** The Fleet manager owns this sender even when the web console is stopped.
  * Events are already durable in their owning task commit, so no second outbox
@@ -7,6 +9,7 @@ export class TaskNotificationProducer {
     warn;
     request;
     timer;
+    dirty = false;
     running;
     offset = 0;
     stopped = false;
@@ -15,14 +18,42 @@ export class TaskNotificationProducer {
         this.config = config;
         this.warn = warn;
         this.request = request;
-        this.timer = setInterval(() => { void this.drain(); }, 3000);
-        this.timer.unref();
+        // Subscribe before startup replay: a commit while fetch is pending needs a second pass.
+        observeFleetResources({ retryWatchFailures: true, paths: [tasksDir()], roots: [] }, state => {
+            if (state.health !== 'healthy')
+                this.warn('Task notification observation unavailable; committed events retained');
+            else {
+                this.dirty = true;
+                void this.drain();
+            }
+        }, this.shutdown.signal);
         void this.drain();
     }
     drain() {
-        return this.running ??= this.drainOnce().catch(() => {
+        if (this.stopped)
+            return Promise.resolve();
+        if (this.running)
+            return this.running;
+        this.dirty = false;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        this.running = this.drainOnce().catch(() => {
             this.warn('Task notification snapshot unavailable; committed events retained');
-        }).finally(() => { this.running = undefined; });
+            this.retry();
+        }).finally(() => {
+            this.running = undefined;
+            if (this.dirty && !this.stopped) {
+                this.dirty = false;
+                void this.drain();
+            }
+        });
+        return this.running;
+    }
+    retry() {
+        if (this.stopped || this.timer)
+            return;
+        this.timer = setTimeout(() => { this.timer = undefined; void this.drain(); }, 3000);
+        this.timer.unref();
     }
     async drainOnce() {
         if (this.stopped)
@@ -33,6 +64,8 @@ export class TaskNotificationProducer {
         const start = this.offset % pending.length;
         const batch = [...pending.slice(start), ...pending.slice(0, start)].slice(0, 32);
         this.offset = start + batch.length;
+        // Retry only outstanding work; never run an idle discovery timer.
+        this.retry();
         for (let index = 0; index < batch.length; index += 4) {
             if (this.stopped)
                 break;
@@ -63,5 +96,5 @@ export class TaskNotificationProducer {
             }));
         }
     }
-    async close() { this.stopped = true; clearInterval(this.timer); this.shutdown.abort(); await this.running; }
+    async close() { this.stopped = true; clearTimeout(this.timer); this.shutdown.abort(); await this.running; }
 }

package/dist/ops.js

@@ -271,7 +271,7 @@ export async function rmRole(cfg, name, deps) {
     rmSync(agentDir(name), { recursive: true, force: true });
     if (generatedSource && existsSync(role.sourceFile)) {
         unlinkSync(role.sourceFile);
-        await retireNotificationTarget(`/fleet/chats/agents/${encodeURIComponent(name)}`).catch(() => { });
+        await retireNotificationTarget({ kind: 'agent', agentId: name }).catch(() => { });
         deps.log(`removed ${role.sourceFile}`);
     }
     deps.log(`removed '${name}' (its ours identity is left intact)`);