@ours.network/fleet 2.0.3 → 2.1.0

package/README.md

@@ -485,7 +485,6 @@ Additional operational field inventory (schematic, not one YAML document):
       owners: [owner-contact-cid]        # authenticated ours contact IDs, never display names
       agent: managed-agent-cid           # exact role CID allowed to relay messages/files outward
       interrupt: false                  # false queues; true cancels current work first
-      progress_interval_ms: 30000        # fleet-generated progress notices; 0 disables
       comments: true                    # relay live "🟡 Live update:" structured commentary (default true);
                                         #   restart baseline for /comments on|off
       attachments:                      # secure inbound documents, images, and voice
@@ -1962,3 +1961,13 @@ App released. The currently pinned Fleet nightly.41 does not support v2 grants.
 These source changes do not publish, merge, or deploy any component.
 
 See [ACP file sending](docs/acp-files.md) for the same-chat `send_file` flow, available to every Agent by default, and its supported sessions.
+
+### Owner-channel activity display
+
+Routine tool activity is shown as one updating status in the app, outside message
+history. Fleet no longer sends periodic tool-counter messages. The
+`owner_channel.progress_interval_ms` setting has been removed; remove it from
+existing role/default configuration when applying this change. Meaningful agent
+commentary, attention requests and final answers continue to be delivered.
+The app associates activity with the channel's bound CID, never a display name.
+It shows unavailable status when the directory observation disconnects.

package/dist/application/fleet-query-service.js

@@ -165,6 +165,8 @@ export class FleetQueryService {
                 return {
                     backend: intended, reachability: snapshot.alive ? 'online' : 'offline',
                     readiness: snapshot.readiness, evidence: 'authoritative',
+                    ...(typeof snapshot.ownerChannelCid === 'string' && /^[a-f0-9]{64}$/i.test(snapshot.ownerChannelCid)
+                        ? { ownerChannelCid: snapshot.ownerChannelCid.toLowerCase() } : {}),
                     sessionId: snapshot.sessionId, lastError: snapshot.lastError,
                     pendingPermissionId: snapshot.pendingPermissionId,
                     protocolVersion: snapshot.protocolVersion, features: snapshot.features,

package/dist/application/room-layout-definitions.js

@@ -14,6 +14,7 @@ import { loadConfig, splitRootFor } from '../config.js';
 import { assertLayoutFile, validLayoutKey, validateRoomLayout } from '../rooms-tasks/layout-config.js';
 import { FleetError } from './errors.js';
 import { layoutDefinitionHash } from './task-layouts.js';
+import { EMPTY_TASK_LAYOUT } from '../rooms-tasks/empty-layout.js';
 export const ABSENT_REVISION = 'absent';
 const revisionOf = (bytes) => createHash('sha256').update(bytes).digest('hex');
 export class RoomLayoutDefinitions {
@@ -25,6 +26,8 @@ export class RoomLayoutDefinitions {
     }
     root() { return join(splitRootFor(this.configPath ?? defaultConfigPath()), 'room_layouts'); }
     pathFor(name) {
+        if (name === EMPTY_TASK_LAYOUT)
+            throw new FleetError('invalid_request', 'the built-in empty layout cannot be edited or deleted');
         if (!validLayoutKey(name))
             throw new FleetError('invalid_request', 'layout name must start with a letter and use letters, digits, - or _');
         return join(this.root(), `${name}.yaml`);
@@ -68,6 +71,8 @@ export class RoomLayoutDefinitions {
         return readdirSync(root).filter(file => /\.ya?ml$/.test(file)).sort().map(file => {
             const name = basename(file, extname(file)), path = join(root, file);
             try {
+                if (name === EMPTY_TASK_LAYOUT)
+                    throw Error('reserved built-in layout name');
                 if (!validLayoutKey(name))
                     throw Error(`invalid room layout id: ${name}`);
                 assertLayoutFile(path);

package/dist/application/task-layouts.d.ts

@@ -1,7 +1,7 @@
 import { type RoomLayoutDefinition } from '../rooms-tasks/layout-config.js';
 import { RoomLayoutService } from '../rooms-tasks/layout-service.js';
 import type { TaskLayoutLink, TaskRecord } from '../rooms-tasks/types.js';
-export type TaskLayoutOperation = 'open' | 'close-room' | 'close';
+export type TaskLayoutOperation = 'start' | 'open' | 'close-room' | 'close';
 export interface TaskLayoutOperationRecord {
     /** Only the worker holding the current ID may update the record. */
     id: string;
@@ -73,6 +73,15 @@ export declare class TaskLayouts {
     runExists(link: TaskLayoutLink): boolean;
     /** Idempotent: reuse a run whose provenance matches this task, or snapshot one from the pinned source. */
     ensureRun(task: TaskRecord, precondition?: (current: TaskRecord) => void): Promise<void>;
+    /** Starting a mission initializes every room and its required agents before Active. */
+    initializeRooms(task: TaskRecord): Promise<void>;
+    addMember(task: TaskRecord, input: {
+        key: string;
+        role: string;
+        requestId: string;
+        hash: string;
+        definition: import('../config.js').AgentTemplateDefinition;
+    }): Promise<void>;
     private verifyProvenance;
     readOperation(runId: string): TaskLayoutOperationRecord | undefined;
     /** Update only the still-current operation; a superseded or forgotten one is never resurrected. */

package/dist/application/task-layouts.js

@@ -11,7 +11,7 @@ import { join } from 'node:path';
 import { canonicalJson } from '../canonical-json.js';
 import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
 import { assertLayoutFile } from '../rooms-tasks/layout-config.js';
-import { getTask as readTask } from '../rooms-tasks/task-state.js';
+import { getTask as readTask, activateTask, blockTask } from '../rooms-tasks/task-state.js';
 import { stateRoot } from '../paths.js';
 import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
 import { layoutSupervisorId } from '../rooms-tasks/layout-control.js';
@@ -20,6 +20,7 @@ import { FleetError } from './errors.js';
 import { ownedLayoutRetirementSeats } from '../rooms-tasks/layout-member-retirement.js';
 import { eraseMemberArtifacts } from '../rooms-tasks/erasure.js';
 import { assertTaskRegistrationsAbsent } from '../supervisor/catalog.js';
+import { EMPTY_TASK_LAYOUT, EMPTY_TASK_ROOM } from '../rooms-tasks/empty-layout.js';
 /** Hash of the authorable definition only (never the source file path). */
 export function layoutDefinitionHash(definition) {
     const { version, description, participants, rooms } = definition;
@@ -95,12 +96,35 @@ export class TaskLayouts {
             if (layoutDefinitionHash(source) !== link.definition_hash)
                 throw Error(`room layout ${link.name} changed before this task's layout run was created; create a new task to use the edited layout`);
             const scoped = taskScopedDefinition(structuredClone(source), current);
+            if (link.name === EMPTY_TASK_LAYOUT)
+                scoped.rooms[EMPTY_TASK_ROOM].goal = current.brief?.trim() || current.title;
             const provenance = { task_id: current.task_id, source_hash: link.definition_hash, scoped_hash: layoutDefinitionHash(scoped) };
             // Provenance precedes the run: a crash in between is re-derived from the same pinned source.
             replaceFileAtomically(this.provenancePath(link.run_id), JSON.stringify(provenance), 0o600);
             await service.create(link.name, {}, link.run_id, { source: scoped, cwd: current.workspace?.path });
         });
     }
+    /** Starting a mission initializes every room and its required agents before Active. */
+    async initializeRooms(task) {
+        await this.withTaskLock(task.layout.run_id, async () => {
+            const current = readTask(task.task_id);
+            if (current.deletion?.status === 'pending' || current.terminal_intent || !['provisioning', 'active'].includes(current.state))
+                throw new FleetError('conflict', 'task is no longer starting; its room cannot be opened');
+            this.verifyProvenance(current);
+            const engine = this.service().open(task.layout.run_id);
+            for (const key of Object.keys(engine.snapshot().definition.rooms))
+                await engine.activate(layoutSupervisorId(), key);
+        });
+    }
+    async addMember(task, input) {
+        const link = task.layout;
+        await this.withTaskLock(link.run_id, async () => {
+            const current = readTask(task.task_id);
+            assertLayoutOpenable(current);
+            this.verifyProvenance(current);
+            await this.service().open(link.run_id).addMember(layoutSupervisorId(), { ...input, room: EMPTY_TASK_ROOM });
+        });
+    }
     verifyProvenance(task) {
         const link = task.layout, path = this.provenancePath(link.run_id);
         let provenance;
@@ -151,15 +175,18 @@ export class TaskLayouts {
             ...(state.uncertain ? { uncertain: state.uncertain } : {}),
             rooms: Object.entries(state.definition.rooms).map(([key, spec]) => {
                 const room = state.rooms[key];
+                const additions = Object.entries(state.additional_members ?? {}).filter(([, member]) => member.room === key);
+                const roles = { ...spec.roles, ...Object.fromEntries(additions.map(([name, member]) => [name, member.role])) };
                 return {
-                    key, goal: spec.goal, members: [...spec.members], ...(spec.roles ? { roles: { ...spec.roles } } : {}),
+                    key, goal: spec.goal, members: [...spec.members, ...additions.map(([name]) => name)],
+                    ...(Object.keys(roles).length ? { roles } : {}),
                     state: room?.state ?? 'declared', ready: [...(room?.ready ?? [])],
                     ...(room?.native ? { room_id: room.native.room_id, identity_cid: room.native.identity_cid } : {}),
                 };
             }),
             participants: Object.entries(state.participants).map(([key, p]) => ({
                 key, ...(p.participant ? { participant: p.participant, room: p.room } : {}),
-                agent_template: state.definition.participants[p.participant ?? key]?.agent_template, owned: p.owned, retired: Boolean(p.retired),
+                agent_template: state.definition.participants[p.participant ?? key]?.agent_template ?? state.additional_members?.[key]?.template, owned: p.owned, retired: Boolean(p.retired),
                 ...(p.instance?.agent ? { agent: p.instance.agent } : {}), ...(p.instance?.cid ? { cid: p.instance.cid } : {}),
             })),
         };
@@ -169,7 +196,7 @@ export class TaskLayouts {
         const link = task.layout;
         if (!link)
             throw Error(`task ${task.task_id} has no layout`);
-        if (operation !== 'close' && (!room || !ROOM_KEY.test(room)))
+        if (!['start', 'close'].includes(operation) && (!room || !ROOM_KEY.test(room)))
             throw new FleetError('invalid_request', 'a valid room key is required');
         if (room) {
             const definition = this.runExists(link) ? this.service().open(link.run_id, true).snapshot().definition : undefined;
@@ -177,13 +204,20 @@ export class TaskLayouts {
                 throw new FleetError('resource_not_found', `unknown layout room: ${room}`);
         }
         const record = { id: randomUUID(), operation, ...(room ? { room } : {}), status: 'launching' };
-        await withFileLock(this.operationPath(link.run_id) + '.lock', () => {
+        let accepted = false;
+        const selected = await withFileLock(this.operationPath(link.run_id) + '.lock', () => {
             const current = this.readOperation(link.run_id);
             // Full close always proceeds: terminal cleanup must not wait behind an open; the engine lock serializes them.
+            if (operation === 'start' && current?.operation === 'start' && ['launching', 'running'].includes(current.status) && Date.now() - Date.parse(current.updated_at) < 10 * 60_000)
+                return current;
             if (operation !== 'close' && current && ['launching', 'running'].includes(current.status) && Date.now() - Date.parse(current.updated_at) < 10 * 60_000)
                 throw new FleetError('conflict', `layout operation already in progress: ${current.operation}${current.room ? ' ' + current.room : ''}`);
             this.writeOperation(link.run_id, record);
+            accepted = true;
+            return record;
         });
+        if (!accepted)
+            return selected;
         const args = ['task', '_layout', task.task_id, operation, ...(room ? [room] : []), '--operation-id', record.id];
         const launch = this.deps.launch
             ?? ((cli, name) => launchFleetWorker(cli, name, this.configPath, this.deps.binPath?.()));
@@ -218,6 +252,20 @@ export class TaskLayouts {
     }
     async perform(task, operation, room) {
         const link = task.layout;
+        if (operation === 'start') {
+            try {
+                await this.initializeRooms(task);
+                if (readTask(task.task_id).state !== 'active')
+                    activateTask(task.task_id);
+            }
+            catch (error) {
+                const current = readTask(task.task_id);
+                if (current.state === 'provisioning' && !current.terminal_intent && current.deletion?.status !== 'pending')
+                    blockTask(task.task_id, `layout startup failed: ${error.message}`);
+                throw error;
+            }
+            return;
+        }
         if (operation === 'open') {
             // Re-read under the task-layout lock: a deletion or terminal action accepted after HTTP admission wins.
             await this.ensureRun(task, assertLayoutOpenable);

package/dist/application/task-room-service.d.ts

@@ -79,6 +79,8 @@ export interface CreateTaskRequest {
     anonymous?: boolean;
     /** Room Layout name: the task's rooms and participants come from a layout run. */
     layout?: string;
+    /** HTTP acceptance returns while a detached worker initializes the layout. */
+    deferLayoutStart?: boolean;
 }
 export interface CreateRoomRequest {
     actor: TaskRoomActor;
@@ -167,7 +169,7 @@ export declare class TaskRoomApplicationService {
     runTaskLayoutOperation(input: {
         actor: TaskRoomActor;
         taskId: string;
-        operation: 'open' | 'close-room' | 'close';
+        operation: 'start' | 'open' | 'close-room' | 'close';
         room?: string;
         operationId?: string;
     }): Promise<import("./task-layouts.js").TaskLayoutView>;
@@ -179,6 +181,7 @@ export declare class TaskRoomApplicationService {
         template?: string;
         members?: MemberOverrides;
         anonymous?: boolean;
+        deferLayoutStart?: boolean;
     }): Promise<TaskRecord>;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
@@ -404,6 +407,7 @@ export declare class TaskRoomApplicationService {
         template?: string;
         members?: MemberOverrides;
         anonymous?: boolean;
+        deferLayoutStart?: boolean;
     }): Promise<{
         task: TaskRecord;
         status: 'ready' | 'already_active' | 'in_progress';

package/dist/application/task-room-service.js

@@ -1,4 +1,5 @@
 import { TaskLayouts, assertLayoutOpenable, writeTaskBrief } from './task-layouts.js';
+import { EMPTY_TASK_LAYOUT } from '../rooms-tasks/empty-layout.js';
 import { FleetError } from './errors.js';
 import { readFileSync } from 'node:fs';
 import { taskLiveReadiness } from '../rooms-tasks/live-readiness.js';
@@ -78,7 +79,7 @@ export class TaskRoomApplicationService {
         const { requestMemberAddition } = await import('../rooms-tasks/add-member.js');
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return requestMemberAddition({ taskId, request, cfg, configPath: this.configurationPath,
-            cowork: (this.deps.cowork ?? createCoworkAdapter)(cfg), binPath: (this.deps.binPath ?? getBinPath)(), provision: this.deps.provisionMembers });
+            cowork: readTask(taskId).layout ? undefined : (this.deps.cowork ?? createCoworkAdapter)(cfg), binPath: (this.deps.binPath ?? getBinPath)(), provision: this.deps.provisionMembers, layouts: this.layouts() });
     }
     async memberAddition(taskId, requestId) { const { memberAddition } = await import('../rooms-tasks/add-member.js'); return memberAddition(taskId, requestId); }
     layouts() {
@@ -103,10 +104,10 @@ export class TaskRoomApplicationService {
         recordFleetAuditPresentation({ kind: 'task', operation: 'create', id: task.task_id,
             title: task.title, previousState: 'none', newState: task.state, revision: task.created_at,
             list: task.list_name ?? 'default', roomId: undefined, template: `layout:${layout.name}`, agents: [] });
-        return task.state === 'provisioning' ? (await this.ensureLayoutWork(task)).task : task;
+        return task.state === 'provisioning' ? (await this.ensureLayoutWork(task, request.deferLayoutStart)).task : task;
     }
     /** Layout tasks never provision the legacy single room; their run is a local snapshot. */
-    async ensureLayoutWork(task) {
+    async ensureLayoutWork(task, defer = false) {
         if (TASK_TERMINAL_STATES.includes(task.state))
             throw new TaskRoomApplicationError('task_terminal', 'task terminal', { task: task.task_id, state: task.state });
         if (task.state === 'active' || task.state === 'review')
@@ -119,6 +120,11 @@ export class TaskRoomApplicationService {
         }
         try {
             await this.layouts().ensureRun(task);
+            if (defer) {
+                await this.layouts().launch(task, 'start');
+                return { task: readTask(task.task_id), status: 'in_progress' };
+            }
+            await this.layouts().initializeRooms(task);
         }
         catch (error) {
             const reason = `layout run could not be created: ${error.message}`;
@@ -362,10 +368,11 @@ export class TaskRoomApplicationService {
             const blocker = task.outcome?.summary ?? task.blocked?.reason;
             return {
                 kind: failed ? 'failed' : ready ? 'ready' : 'in_progress', task, room: undefined,
-                launch: { template: `layout:${task.layout.name}`, anonymous: false, owner_attached: false },
+                launch: { template: `layout:${task.layout.name}`, anonymous: false,
+                    owner_attached: task.layout.name === EMPTY_TASK_LAYOUT && this.layouts().view(task)?.rooms.some(room => room.state === 'active') === true },
                 members: { expected: 0, active: 0, launched: 0 },
                 ...(blocker ? { blocker } : {}),
-                ...(!ready && !failed ? { next_action: `Correct the blocker, then run ours-fleet task start ${task.task_id}.` } : {}),
+                ...(!ready && !failed && blocker ? { next_action: `Correct the blocker, then run ours-fleet task start ${task.task_id}.` } : {}),
             };
         }
         const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
@@ -584,6 +591,8 @@ export class TaskRoomApplicationService {
     }
     async launchTaskProvisioning(taskId) {
         const outcome = this.taskProvisioningOutcome(taskId);
+        if (outcome.task.layout)
+            return outcome; // layout startup already has its own durable operation/worker
         if (outcome.kind === 'in_progress' && !outcome.next_action) {
             await launchFleetWorker(['task', '_provision', taskId], `task-provision-${taskId}`, this.configurationPath, this.deps.binPath?.());
         }
@@ -882,7 +891,7 @@ export class TaskRoomApplicationService {
         if (task.layout) {
             if (input.template || input.members || input.anonymous !== undefined)
                 throw new FleetError('invalid_request', 'a layout task cannot take a room template or member overrides');
-            return this.ensureLayoutWork(task);
+            return this.ensureLayoutWork(task, input.deferLayoutStart);
         }
         const recordedRoom = task.room_id ? getRoomRecord(task.room_id) : undefined;
         const recordedPolicy = storedRoomLaunchPolicy(recordedRoom?.room_policy ?? task.execution_plan?.room_policy);

package/dist/application/types.d.ts

@@ -62,6 +62,8 @@ export interface RoleStatus {
         detail: string;
     };
     session: {
+        /** Supervisor-bound owner mailbox, distinct from the managed agent identity. */
+        ownerChannelCid?: string;
         backend: SessionBackendId | 'unknown';
         reachability: 'online' | 'offline' | 'unavailable' | 'unknown';
         readiness: 'starting' | 'idle' | 'running' | 'awaiting_permission' | 'failed' | 'unknown';

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "2.0.3",
-  "buildId": "495dcfb38c4e",
-  "commit": "6bc5bab0c0b088acd40d1a79fe5244730dde4708",
+  "version": "2.1.0",
+  "buildId": "697e8bf9e53c",
+  "commit": "2805e0e84c2a3bad05efdbe895fd8fb6e9d2aff4",
   "dirty": false,
-  "builtAt": "2026-10-23T08:54:42.810Z",
+  "builtAt": "2026-10-27T12:22:22.859Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

package/dist/config.d.ts

@@ -101,8 +101,6 @@ export interface OwnerChannelConfig {
     agent?: string;
     /** Cancel active work before each owner request instead of queueing it. */
     interrupt: boolean;
-    /** Deterministic in-progress notice interval; 0 disables progress notices. */
-    progress_interval_ms: number;
     /**
      * Relay the agent's live ACP commentary to the owner while a turn runs.
      * This is the RESTART BASELINE only: `/comments on|off` changes the running

package/dist/config.js

@@ -882,8 +882,11 @@ export function resolveOwnerChannelConfig(defaults, role, session, file = 'confi
         ...(role ?? {}),
     };
     const allowed = [
-        'identity', 'owners', 'agent', 'interrupt', 'progress_interval_ms', 'comments', 'attachments',
+        'identity', 'owners', 'agent', 'interrupt', 'comments', 'attachments',
     ];
+    if ('progress_interval_ms' in merged)
+        throw new ConfigError(`${file}: role '${name}' owner_channel.progress_interval_ms has been removed; delete it. `
+            + 'Routine tool activity is shown as one status in the app instead of periodic chat messages');
     const bad = Object.keys(merged).filter(key => !allowed.includes(key));
     if (bad.length)
         throw new ConfigError(`${file}: role '${name}' owner_channel: unknown key(s) ${bad.join(', ')}`);
@@ -905,10 +908,6 @@ export function resolveOwnerChannelConfig(defaults, role, session, file = 'confi
         throw new ConfigError(`${file}: role '${name}' owner_channel.owners must contain exact 64-hex CIDs when agent relay is configured`);
     if (merged.interrupt !== undefined && typeof merged.interrupt !== 'boolean')
         throw new ConfigError(`${file}: role '${name}' owner_channel.interrupt must be true or false`);
-    if (merged.progress_interval_ms !== undefined
-        && (typeof merged.progress_interval_ms !== 'number'
-            || !Number.isFinite(merged.progress_interval_ms) || merged.progress_interval_ms < 0))
-        throw new ConfigError(`${file}: role '${name}' owner_channel.progress_interval_ms must be a non-negative number`);
     if (merged.comments !== undefined && typeof merged.comments !== 'boolean')
         throw new ConfigError(`${file}: role '${name}' owner_channel.comments must be true or false`);
     if (defaultInput.attachments !== undefined && !isPlainObject(defaultInput.attachments))
@@ -949,7 +948,6 @@ export function resolveOwnerChannelConfig(defaults, role, session, file = 'confi
         owners,
         ...(agent ? { agent } : {}),
         interrupt: merged.interrupt ?? false,
-        progress_interval_ms: merged.progress_interval_ms ?? 30_000,
         // Default true preserves the established live-commentary behavior; an
         // upgrade never silently goes quiet on an owner who relied on it.
         comments: merged.comments ?? true,