@ours.network/fleet 1.2.0-nightly.55 → 1.2.0-nightly.57

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.55",
-  "buildId": "6e4199ab6d73",
-  "commit": "a66362bc99a9896700192f5ff2c8454a0e209766",
+  "version": "1.2.0-nightly.57",
+  "buildId": "e1efd9a9bfd5",
+  "commit": "c94b8b63da1f7f0bab4ba1dec0c43a9e455b2366",
   "dirty": true,
-  "builtAt": "2026-10-09T12:16:42.572Z",
+  "builtAt": "2026-10-10T18:15:52.108Z",
   "capabilities": [
     "managed-cli.codex-reasoning-effort-v1",
     "managed-cli.setup-v1",

package/dist/creation.d.ts

@@ -153,7 +153,7 @@ export interface DaemonIdentityProvisionerOptions {
 export declare function daemonIdentityProvisioner(env?: NodeJS.ProcessEnv, attachClient?: (options: AttachOursClientOptions) => Promise<IdentityInventoryClient>, options?: DaemonIdentityProvisionerOptions): IdentityProvisioner;
 /** Inventory-only variant for session-owned temporary identity lifecycles. */
 export declare function daemonIdentityInventoryProvisioner(env?: NodeJS.ProcessEnv, attachClient?: (options: AttachOursClientOptions) => Promise<IdentityInventoryClient>): IdentityProvisioner;
-/** Atomically write a bare Agent file, journalling it for rollback. */
+/** Atomically write an owner-private Agent file, journalling it for rollback. */
 export declare function writeRoleFile(tx: CreationTransaction, file: string, contents: string): void;
 /** Where a setting's effective value came from. */
 export type ProvenanceSource = 'cli' | 'agent-template' | 'fleet-default' | 'caller-role' | 'built-in';

package/dist/creation.js

@@ -294,10 +294,10 @@ export function daemonIdentityInventoryProvisioner(env = process.env, attachClie
         acceptTemporaryExisting: true,
     });
 }
-/** Atomically write a bare Agent file, journalling it for rollback. */
+/** Atomically write an owner-private Agent file, journalling it for rollback. */
 export function writeRoleFile(tx, file, contents) {
     const existed = existsSync(file);
-    replaceFileAtomically(file, contents, 0o644);
+    replaceFileAtomically(file, contents, 0o600);
     tx.record({
         stage: `Agent file ${file}`,
         // Only remove what THIS transaction created; never delete a file the

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

@@ -0,0 +1,18 @@
+import type { ProducerConfig } from './outbox.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
+ * admission/crash window is needed. A failed task does not block other tasks. */
+export declare class TaskNotificationProducer {
+    private readonly config;
+    private readonly warn;
+    private readonly request;
+    private readonly timer;
+    private running?;
+    private offset;
+    private stopped;
+    private readonly shutdown;
+    constructor(config: ProducerConfig, warn?: (line: string) => void, request?: typeof fetch);
+    drain(): Promise<void>;
+    private drainOnce;
+    close(): Promise<void>;
+}

package/dist/notifications/task-producer.js

@@ -0,0 +1,67 @@
+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
+ * admission/crash window is needed. A failed task does not block other tasks. */
+export class TaskNotificationProducer {
+    config;
+    warn;
+    request;
+    timer;
+    running;
+    offset = 0;
+    stopped = false;
+    shutdown = new AbortController();
+    constructor(config, warn = () => { }, request = fetch) {
+        this.config = config;
+        this.warn = warn;
+        this.request = request;
+        this.timer = setInterval(() => { void this.drain(); }, 3000);
+        this.timer.unref();
+        void this.drain();
+    }
+    drain() {
+        return this.running ??= this.drainOnce().catch(() => {
+            this.warn('Task notification snapshot unavailable; committed events retained');
+        }).finally(() => { this.running = undefined; });
+    }
+    async drainOnce() {
+        if (this.stopped)
+            return;
+        const pending = pendingTaskNotifications(this.warn);
+        if (!pending.length)
+            return;
+        const start = this.offset % pending.length;
+        const batch = [...pending.slice(start), ...pending.slice(0, start)].slice(0, 32);
+        this.offset = start + batch.length;
+        for (let index = 0; index < batch.length; index += 4) {
+            if (this.stopped)
+                break;
+            await Promise.all(batch.slice(index, index + 4).map(async (task) => {
+                for (const event of task.events.slice(0, 32)) {
+                    if (this.stopped)
+                        break;
+                    try {
+                        const response = await this.request(this.config.origin + '/api/v1/send', {
+                            method: 'POST', redirect: 'error', signal: AbortSignal.any([this.shutdown.signal, AbortSignal.timeout(10_000)]),
+                            headers: { ...(this.config.gatewayCredential
+                                    ? { 'X-Ours-Api-Token': this.config.gatewayCredential, 'X-Ours-Notifications-Producer': this.config.token }
+                                    : { Authorization: `Bearer ${this.config.token}` }), 'Content-Type': 'application/json' },
+                            body: JSON.stringify(event),
+                        });
+                        await response.body?.cancel();
+                        if (!response.ok) {
+                            this.warn(`Task notification delivery pending (HTTP ${response.status}); committed event retained`);
+                            break;
+                        }
+                        acknowledgeTaskNotification(task.taskId, event.eventId);
+                    }
+                    catch {
+                        this.warn('Task notification delivery pending; committed event retained');
+                        break;
+                    }
+                }
+            }));
+        }
+    }
+    async close() { this.stopped = true; clearInterval(this.timer); this.shutdown.abort(); await this.running; }
+}

package/dist/rooms-tasks/task-state.d.ts

@@ -1,8 +1,15 @@
 import type { ArchivedMemberAbsence } from './types.js';
-import type { TaskRecord, TaskState, TaskOrigin, TaskTemplateRef, TaskOutcome, TaskMemberRole, TaskTerminalIntent, TaskDeletionActor, TaskDeletionMemberPhase } from './types.js';
+import type { TaskRecord, TaskState, TaskOrigin, TaskTemplateRef, TaskOutcome, TaskMemberRole, TaskTerminalIntent, TaskDeletionActor, TaskDeletionMemberPhase, TaskNotificationEvent } from './types.js';
 export declare const tasksDir: () => string;
 export declare class TaskStateError extends Error {
 }
+/** Atomic snapshots contain the events, including intermediate states between polls. */
+export declare function pendingTaskNotifications(warn?: (line: string) => void): Array<{
+    taskId: string;
+    events: TaskNotificationEvent[];
+}>;
+/** Service event-id dedupe covers acceptance followed by a crash before this acknowledgement. */
+export declare function acknowledgeTaskNotification(id: string, eventId: string): void;
 /**
  * Accepted deletion is the per-task epoch guard: once pending, every lifecycle
  * mutation, terminal settlement, and room publication must fail boundedly.

package/dist/rooms-tasks/task-state.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, rmSync, renameSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, rmSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { replaceFileAtomically } from '../atomic-file.js';
@@ -89,8 +89,77 @@ function writeTask(record) {
     mkdirSync(tasksDir(), { recursive: true });
     const persisted = { ...record };
     delete persisted.list_name;
+    const path = taskPath(record.task_id);
+    const previous = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : undefined;
+    const status = (task) => task.deletion?.status === 'pending' ? 'deleting' : task.blocked ? `${task.state} (blocked)` : task.state;
+    // Read pending events under the same task lock as every mutation. Metadata edits
+    // and retries preserve the queue; acknowledgement cannot be resurrected by stale input.
+    const pending = [...(previous?.notification_events ?? [])];
+    if (!previous || status(previous) !== status(record)) {
+        const next = status(record), before = previous ? status(previous) : undefined;
+        pending.push({ eventId: `task:${record.task_id}:${randomUUID()}`, taskId: record.task_id,
+            title: `Task ${!previous ? 'created' : 'updated'}: ${record.title}`.slice(0, 160),
+            body: `Task ${record.task_id}: ${before ? `${before} → ` : 'created in '}${next}.`,
+            url: `/fleet/tasks/${record.task_id}` });
+    }
+    if (pending.length)
+        persisted.notification_events = pending;
+    else
+        delete persisted.notification_events;
     replaceFileAtomically(taskPath(record.task_id), JSON.stringify(persisted, null, 2) + '\n');
 }
+const retiredNotificationsDir = () => join(tasksDir(), '.notification-retired');
+/** Atomic snapshots contain the events, including intermediate states between polls. */
+export function pendingTaskNotifications(warn = () => { }) {
+    const result = [];
+    for (const dir of [tasksDir(), retiredNotificationsDir()]) {
+        if (!existsSync(dir))
+            continue;
+        for (const file of readdirSync(dir).filter(file => TASK_ID_PATTERN.test(file.slice(0, -5)) && file.endsWith('.json'))) {
+            try {
+                const path = join(dir, file), stat = lstatSync(path);
+                if (!stat.isFile() || stat.isSymbolicLink())
+                    throw new Error('invalid notification source');
+                const value = JSON.parse(readFileSync(path, 'utf8'));
+                const id = file.slice(0, -5);
+                // A prepared deletion copy has no authority while the original still exists.
+                if (dir === retiredNotificationsDir() && existsSync(taskPath(id)))
+                    continue;
+                if (value.notification_events === undefined)
+                    continue;
+                if (!Array.isArray(value.notification_events) || value.notification_events.some(e => !e
+                    || typeof e.eventId !== 'string' || !e.eventId.startsWith(`task:${id}:`) || e.eventId.length > 512
+                    || e.taskId !== id || (e.url !== `/fleet/tasks/${id}` && !(e.eventId === `task:${id}:deleted` && e.url === `/fleet/tasks?deletedTask=${id}`)) || typeof e.title !== 'string' || !e.title.trim() || e.title.length > 160
+                    || typeof e.body !== 'string' || !e.body.trim() || e.body.length > 512))
+                    throw new Error('invalid notification events');
+                if (value.notification_events.length)
+                    result.push({ taskId: id, events: value.notification_events });
+            }
+            catch (error) {
+                if (!isNotFoundError(error))
+                    warn('Task notification record unavailable; other task deliveries continue');
+            }
+        }
+    }
+    return result;
+}
+/** Service event-id dedupe covers acceptance followed by a crash before this acknowledgement. */
+export function acknowledgeTaskNotification(id, eventId) {
+    assertCanonicalTaskId(id);
+    withTaskLock(id, () => {
+        for (const path of [taskPath(id), join(retiredNotificationsDir(), `${id}.json`)]) {
+            if (!existsSync(path))
+                continue;
+            const value = JSON.parse(readFileSync(path, 'utf8'));
+            if (!value.notification_events?.some(event => event.eventId === eventId))
+                continue;
+            value.notification_events = value.notification_events.filter(event => event.eventId !== eventId);
+            replaceFileAtomically(path, JSON.stringify(value, null, 2) + '\n');
+            if (path.startsWith(retiredNotificationsDir() + '/') && !value.notification_events.length)
+                unlinkSync(path);
+        }
+    });
+}
 function presentTask(record) {
     const listId = record.list_id ?? DEFAULT_TASK_LIST_ID;
     const list = readTaskLists().find(item => item.list_id === listId);
@@ -812,6 +881,12 @@ export function unlinkDeletedTask(id) {
         }
         if (stored.deletion?.status !== 'pending')
             throw new TaskStateError(`task ${id} has no pending deletion`);
+        // Preserve committed deliveries outside the record before deletion. A crash
+        // before unlink may replay two copies; both carry identical service dedupe IDs.
+        const removed = { eventId: `task:${id}:deleted`, taskId: id,
+            title: `Task deleted: ${stored.title}`.slice(0, 160), body: `Task ${id}: deleting → deleted.`,
+            url: `/fleet/tasks?deletedTask=${id}` };
+        replaceFileAtomically(join(retiredNotificationsDir(), `${id}.json`), JSON.stringify({ notification_events: [...(stored.notification_events ?? []), removed] }) + '\n');
         try {
             unlinkSync(taskPath(id));
         }

package/dist/rooms-tasks/types.d.ts

@@ -106,7 +106,16 @@ export interface TaskLayoutLink {
     /** sha256 of the canonical source layout definition the run must snapshot. */
     definition_hash: string;
 }
+export interface TaskNotificationEvent {
+    eventId: string;
+    title: string;
+    body: string;
+    url: string;
+    taskId: string;
+}
 export interface TaskRecord {
+    /** Pending lifecycle events, committed atomically with their task change. */
+    notification_events?: TaskNotificationEvent[];
     workspace?: import('./workspace.js').OwnedWorkspace;
     task_id: string;
     /** Stable organizational list identifier. Missing legacy values mean `default`. */

package/dist/supervisor/manager.js

@@ -2,6 +2,8 @@ import { spawn } from 'node:child_process';
 import { closeSync, existsSync, openSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
+import { producerConfig } from '../notifications/outbox.js';
+import { TaskNotificationProducer } from '../notifications/task-producer.js';
 import { acquireOwnerBinderLease } from '../owner-channel/binder.js';
 import { stateRoot } from '../paths.js';
 import { readRestartLedger, writeRestartLedger, backoffFor, RESTART_FAIL_THRESHOLD } from '../runner.js';
@@ -34,6 +36,7 @@ export async function runFleetManager(entrypoint, deps = {}) {
             closeSync(fd);
         }
     });
+    let notifications;
     async function reconcile(key) {
         await withMemberLock(key, async () => {
             const member = readMember(key);
@@ -155,6 +158,14 @@ export async function runFleetManager(entrypoint, deps = {}) {
         });
     }
     try {
+        try {
+            const config = producerConfig(process.env, undefined, log);
+            if (config)
+                notifications = new TaskNotificationProducer(config, log);
+        }
+        catch {
+            log('[fleet] task notifications unavailable; committed events retained');
+        }
         try {
             const { resumeFleetTransfers } = await import('./adoption.js');
             await resumeFleetTransfers(entrypoint, exec);
@@ -178,6 +189,7 @@ export async function runFleetManager(entrypoint, deps = {}) {
     }
     finally {
         stopping = true;
+        await notifications?.close();
         // Shutdown preserves desired intent; the successor resumes the same catalog.
         const deadline = Date.now() + 17_000;
         while (children.size && Date.now() < deadline) {

package/docs/task-workspaces.md

@@ -185,3 +185,41 @@ before erasing task/room/workspace resources. Permanent siblings remain intact.
 Standalone CLI/web removal refuses `TASK_MEMBER_IS_TASK_OWNED`; use the owning
 task lifecycle. Lost/corrupt task or launch records require restoring original
 backup evidence or explicit ownership reconciliation before deletion can finish.
+
+## Owner lifecycle notifications
+
+A task mutation commits its notification event in the same atomic task record as
+its effective status. Creation, backlog, provisioning, active, review, done,
+cancelled and failed are covered; block/unblock and deletion are effective changes
+as well. Editing a description, list, block reason or saga checkpoint is not a
+status transition. Each event freezes the task identity, title, old/new status and
+navigation route at commit time, so several transitions between delivery polls
+remain separate. Legacy records begin emitting on their next actual change and
+are not retroactively announced as newly created.
+
+The Fleet manager drains committed task events without requiring the web console
+or restarting agents. Its notification producer uses the installation's existing
+owner-scoped credential; it grants no agent arbitrary-send capability. Missing
+configuration or service failure retains the events. Delivery acknowledgement
+runs under the task lock and removes only the accepted event, preserving newer
+changes. A corrupt/unreadable task record is isolated with a safe warning, so
+other tasks continue. Bounded rotating batches prevent one rejected task from
+blocking the entire sender. The built-in `default` task list is unchanged.
+
+Deleting is announced only after its intent commits. Before unlink, settlement
+prepares retained pending events plus a stable deleted event outside the task-owned
+workspace. The sender admits that retained copy only when the original task record
+is absent; an interrupted or failed unlink cannot announce deletion. The final
+event opens the task list and includes the removed task's identity. Earlier events
+keep their immutable detail routes, which may be absent after explicit deletion.
+
+A service restart or producer crash after acceptance may replay an event; the
+Notifications service must retain its acceptance receipts across read/delete to
+make that replay harmless. Upgrade Notifications alongside Fleet to obtain this
+stronger guarantee. The service's authenticated delivery diagnostics distinguish
+provider acceptance, retry, expired subscription and foreground suppression.
+Provider acceptance is not evidence of actual phone receipt. iPhone Web Push
+requires a supported Home Screen installation and granted device/browser permission;
+reopen the workspace to reconcile an expired subscription and explicitly re-enable
+permission if it was revoked. Every received push must display a notification to
+honor Safari's user-visible push requirement.

package/package.json

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