@ours.network/fleet 2.0.3 → 2.1.0

package/dist/owner-channel/notices.d.ts

@@ -17,7 +17,6 @@ export interface OwnerCommentsState {
     /** False when this session's backend never emits ACP commentary at all. */
     supported: boolean;
 }
-export type OwnerProgressPhase = 'starting request' | 'waiting behind earlier requests' | 'working on request' | 'planning next step' | 'using tools' | 'reviewing tool results' | 'drafting response' | 'waiting for approval' | 'resuming after permission decision' | 'recovering from session error';
 export declare const ownerNotices: {
     receivedStarted: () => string;
     receivedQueued: (queuedBehind: number) => string;
@@ -43,7 +42,6 @@ export declare const ownerNotices: {
     attachmentRejected: (reason: string) => string;
     attachmentFailed: () => string;
     deliveryFailed: (role: string) => string;
-    progress: (elapsedMs: number, phase: OwnerProgressPhase, started: number, completed: number, activityUpdates?: number) => string;
     /** The labeled form of one relayed ACP live comment. */
     comment: (message: string) => string;
     comments: (state: OwnerCommentsState) => string;

package/dist/owner-channel/notices.js

@@ -5,18 +5,6 @@
  * never be spoofed away by model content.
  */
 export const OWNER_COMMENT_LABEL = '🟡 Live update:';
-const duration = (elapsedMs) => {
-    const seconds = Math.max(0, Math.floor(elapsedMs / 1_000));
-    const hours = Math.floor(seconds / 3_600);
-    const minutes = Math.floor((seconds % 3_600) / 60);
-    const remainder = seconds % 60;
-    return [hours ? `${hours}h` : '', minutes ? `${minutes}m` : '', remainder ? `${remainder}s` : '']
-        .filter(Boolean).join(' ') || '0s';
-};
-const count = (value, singular, plural = `${singular}s`) => `${value} ${value === 1 ? singular : plural}`;
-const joinCounts = (parts) => parts.length < 2
-    ? parts[0] ?? ''
-    : `${parts.slice(0, -1).join(', ')} and ${parts.at(-1)}`;
 export const ownerNotices = {
     receivedStarted: () => 'ℹ️ Message received. The agent has started working on this request now. '
         + 'The response will arrive in this channel when ready.',
@@ -64,19 +52,6 @@ export const ownerNotices = {
     attachmentRejected: (reason) => `⚠️ Attachment rejected: ${reason}.`,
     attachmentFailed: () => '⚠️ Could not securely retrieve or admit this attachment request.',
     deliveryFailed: (role) => `⚠️ Could not deliver this request to ${role}.`,
-    progress: (elapsedMs, phase, started, completed, activityUpdates = 0) => {
-        const counts = [];
-        if (started)
-            counts.push(`${count(started, 'tool action')} started`);
-        if (completed)
-            counts.push(`${count(completed, 'tool action')} completed`);
-        if (activityUpdates)
-            counts.push(`${count(activityUpdates, counts.length ? 'additional activity update' : 'activity update')} observed`);
-        const activity = counts.length
-            ? `${joinCounts(counts)} since the last update.`
-            : 'no new reportable activity since the last update.';
-        return `⏳ Working for ${duration(elapsedMs)} · ${phase} · ${activity}`;
-    },
     /** The labeled form of one relayed ACP live comment. */
     comment: (message) => `${OWNER_COMMENT_LABEL} ${message}`,
     comments: (state) => `🟡 Live updates are ${state.enabled ? 'ON' : 'OFF'} for this session `

package/dist/owner-channel/ours-client.d.ts

@@ -57,6 +57,8 @@ export interface OursOps {
     start(): Promise<void>;
     /** Bind this session's identity. Throws `BOUND_ELSEWHERE` when it is held live. */
     bindIdentity(name: string): Promise<void>;
+    /** CID returned by the current successful mailbox binding; absent while unbound. */
+    boundIdentityCid?(): string | undefined;
     /** Replace the bound identity's advertised typed-command catalog and handlers. */
     registerCommands(commands: OursRegisteredCommand[]): Promise<void>;
     listContacts(): Promise<OursContactsView>;
@@ -132,11 +134,13 @@ export declare class OursSdkClient implements OursOps {
     private readonly log;
     private readonly deps;
     private client?;
+    private boundCid?;
     private terminalReleasePending;
     private readonly leaseToken;
     constructor(env?: Record<string, string>, log?: (line: string) => void, deps?: OursSdkClientDeps);
     start(): Promise<void>;
     bindIdentity(name: string): Promise<void>;
+    boundIdentityCid(): string | undefined;
     registerCommands(commands: OursRegisteredCommand[]): Promise<void>;
     listContacts(): Promise<OursContactsView>;
     generateInvite(name?: string): Promise<OursInviteResult>;

package/dist/owner-channel/ours-client.js

@@ -117,6 +117,7 @@ export class OursSdkClient {
     log;
     deps;
     client;
+    boundCid;
     // Disposing a transport does not discharge this owner's terminal cleanup.
     terminalReleasePending = false;
     leaseToken = `ours-fleet-owner-${process.pid}-${randomUUID()}`;
@@ -141,8 +142,12 @@ export class OursSdkClient {
     async bindIdentity(name) {
         // force is pinned off: the owner channel never evicts another live session
         // from an identity, it waits for the bounded handoff window and then fails.
-        await this.ops().chooseIdentity({ name, force: false });
+        this.boundCid = undefined;
+        const result = await this.ops().chooseIdentity({ name, force: false });
+        if (typeof result.cid === 'string' && /^[a-f0-9]{64}$/i.test(result.cid))
+            this.boundCid = result.cid.toLowerCase();
     }
+    boundIdentityCid() { return this.boundCid; }
     async registerCommands(commands) {
         await this.ops().registerCommands(commands);
     }
@@ -218,6 +223,7 @@ export class OursSdkClient {
                 + 'session must be re-established after an upgrade; files are not queued');
     }
     async close(options = {}) {
+        this.boundCid = undefined;
         const terminal = options.releaseLease !== false;
         // A failed recovery may have disposed its client before normal shutdown.
         // Reattach the same owner through ordinary verified selection; no rebind is

package/dist/rooms-tasks/add-member.d.ts

@@ -2,6 +2,7 @@ import type { FleetConfig } from '../config.js';
 import { TaskStateError } from './task-state.js';
 import { provisionMembers } from './provision.js';
 import type { CoworkAdapter } from './cowork-adapter.js';
+import type { TaskLayouts } from '../application/task-layouts.js';
 export declare class MemberAdditionRejected extends TaskStateError {
     readonly accepted = false;
 }
@@ -29,10 +30,11 @@ export declare function requestMemberAddition(input: {
     taskId: string;
     request: AddMemberRequest;
     cfg: FleetConfig;
-    cowork: CoworkAdapter;
+    cowork?: CoworkAdapter;
     configPath?: string;
     binPath: string;
     provision?: typeof provisionMembers;
+    layouts?: TaskLayouts;
 }): Promise<{
     requestId: string;
     taskId: string;

package/dist/rooms-tasks/add-member.js

@@ -10,6 +10,9 @@ import { getRoomRecord } from './room-state.js';
 import { prepareExecutionPlan } from './member-overrides.js';
 import { sealTemplateSnapshot } from './templates.js';
 import { provisionMembers } from './provision.js';
+import { EMPTY_TASK_LAYOUT, EMPTY_TASK_ROOM } from './empty-layout.js';
+import { layoutOwnedMemberName } from './layout-member-retirement.js';
+import { validLayoutKey } from './layout-config.js';
 export class MemberAdditionRejected extends TaskStateError {
     accepted = false;
 }
@@ -46,6 +49,43 @@ export async function requestMemberAddition(input) {
         }
         const task = getTask(taskId);
         const room = task.room_id && getRoomRecord(task.room_id);
+        if (task.layout?.name === EMPTY_TASK_LAYOUT && input.layouts) {
+            if (!validLayoutKey(r.slot))
+                throw new MemberAdditionRejected('Invalid member name');
+            const view = input.layouts.view(task);
+            if (!['active', 'review'].includes(task.state) || task.terminal_intent || task.deletion?.status === 'pending'
+                || view?.rooms.find(room => room.key === EMPTY_TASK_ROOM)?.state !== 'active' || view.uncertain || view.closing)
+                throw new MemberAdditionRejected('Adding an agent requires an active task room');
+            if (view.participants.some(p => p.key === r.slot))
+                throw new MemberAdditionRejected('This member slot already exists');
+            if (r.slot === (input.cfg.rooms?.owner.role ?? 'Owner'))
+                throw new MemberAdditionRejected('A member cannot use the Owner role');
+            const definition = (() => {
+                try {
+                    const plan = prepareExecutionPlan({ name: 'additional-member', version: 1, description: 'Additional task participant',
+                        members: [{ slot: r.slot, role: r.slot, count: 1, agent_template: r.agentTemplate }] }, input.cfg, { [r.slot]: { role: r.role, brain: r.brain, ...(task.workspace ? { cwd: task.workspace.path } : {}) } });
+                    return Object.values(plan.launchDefinitions)[0];
+                }
+                catch (error) {
+                    throw new MemberAdditionRejected(error instanceof Error ? error.message : 'Invalid member configuration');
+                }
+            })();
+            const receipt = { taskId, requestId: r.requestId,
+                roleId: layoutOwnedMemberName(task.layout.run_id, r.slot), hash, state: 'running' };
+            const save = () => { replaceFileAtomically(path, JSON.stringify(receipt) + '\n', 0o600); publishFleetResourceCommit(path); };
+            save();
+            running.add(path);
+            void input.layouts.addMember(task, { key: r.slot, role: r.slot, requestId: r.requestId, hash, definition }).then(() => {
+                receipt.state = 'succeeded';
+            }).catch(() => { receipt.state = 'attention'; receipt.error = 'Member launch is not confirmed. Inspect the task layout and agent before recovery.'; })
+                .finally(() => { try {
+                save();
+            }
+            finally {
+                running.delete(path);
+            } }).catch(() => { running.delete(path); });
+            return memberAddition(taskId, r.requestId);
+        }
         if (!room || !['active', 'review'].includes(task.state) || task.terminal_intent || room.state !== 'active'
             || room.task_id !== taskId || room.room_identity_cid !== task.room_identity_cid)
             throw new MemberAdditionRejected('Adding an agent requires an active task room');

package/dist/rooms-tasks/cli.js

@@ -1334,12 +1334,12 @@ export function registerTaskCommands(parent, cOpt) {
         }
     });
     cOpt(taskCmd.command('_layout <id> <operation> [room]', { hidden: true }))
-        .description('internal: run an accepted layout room operation (open, close-room, close)')
+        .description('internal: run an accepted layout operation (start, open, close-room, close)')
         .option('--json', 'JSON output')
         .option('--operation-id <id>', 'accepted operation ID; status updates apply only while it is current')
         .action(async (id, operation, room, opts) => {
         try {
-            if (!['open', 'close-room', 'close'].includes(operation))
+            if (!['start', 'open', 'close-room', 'close'].includes(operation))
                 throw new Error(`unknown layout operation: ${operation}`);
             const view = await taskRoomService(opts.configuration).runTaskLayoutOperation({
                 actor: { kind: 'internal_worker', surface: 'cli' }, taskId: id,

package/dist/rooms-tasks/empty-layout.d.ts

@@ -0,0 +1,5 @@
+import type { RoomLayoutDefinition } from './layout-config.js';
+/** Reserved built-in source; task runs snapshot it just like a saved layout. */
+export declare const EMPTY_TASK_LAYOUT = "builtin-empty";
+export declare const EMPTY_TASK_ROOM = "mission";
+export declare function emptyTaskLayout(): RoomLayoutDefinition;

package/dist/rooms-tasks/empty-layout.js

@@ -0,0 +1,8 @@
+/** Reserved built-in source; task runs snapshot it just like a saved layout. */
+export const EMPTY_TASK_LAYOUT = 'builtin-empty';
+export const EMPTY_TASK_ROOM = 'mission';
+export function emptyTaskLayout() {
+    return { version: 1, participants: {}, rooms: {
+            [EMPTY_TASK_ROOM]: { goal: 'Work on the mission', members: [] },
+        } };
+}

package/dist/rooms-tasks/layout-config.js

@@ -24,8 +24,8 @@ export function validateRoomLayout(raw, label = 'room layout') {
         text(doc.description, `${label}.description`);
     for (const section of ['participants', 'rooms']) {
         const value = doc[section];
-        if (!value || typeof value !== 'object' || Array.isArray(value) || !Object.keys(value).length)
-            throw Error(`${label}.${section}: non-empty mapping required`);
+        if (!value || typeof value !== 'object' || Array.isArray(value) || (section === 'rooms' && !Object.keys(value).length))
+            throw Error(`${label}.${section}: ${section === 'rooms' ? 'non-empty ' : ''}mapping required`);
         for (const key of Object.keys(value))
             if (!validLayoutKey(key))
                 throw Error(`${label}: invalid key ${key}`);

package/dist/rooms-tasks/layout-service.d.ts

@@ -12,7 +12,7 @@ export declare class NativeLayoutSupervisor implements LayoutSupervisor {
     inspect(agent: string, temporary: boolean): Promise<LayoutInstance>;
     private call;
     verify(i: LayoutInstance): Promise<void>;
-    spawn(key: string, template: string): Promise<LayoutInstance>;
+    spawn(key: string, template: string, snapshot?: AgentTemplateDefinition): Promise<LayoutInstance>;
     join(i: LayoutInstance, invite: string, roomCid: string, membership?: {
         roomId: string;
         role: string;

package/dist/rooms-tasks/layout-service.js

@@ -14,6 +14,7 @@ import { callRemoteLayoutBinding } from './layout-binding-client.js';
 import { readClientProfile } from '../client-profile.js';
 import { tempSupervisorLiveness } from '../temp-lifecycle.js';
 import { layoutOwnedMemberName, retireOwnedLayoutMember } from './layout-member-retirement.js';
+import { EMPTY_TASK_LAYOUT, emptyTaskLayout } from './empty-layout.js';
 export class NativeLayoutSupervisor {
     configPath;
     runId;
@@ -47,8 +48,8 @@ export class NativeLayoutSupervisor {
         return this.request(i.agent, i.temporary, { ...request, instance: i });
     }
     async verify(i) { await this.call(i, { action: 'verify' }); }
-    async spawn(key, template) {
-        const definition = this.templates[template];
+    async spawn(key, template, snapshot) {
+        const definition = snapshot ?? this.templates[template];
         if (!definition)
             throw Error(`agent template not found in run snapshot: ${template}`);
         const name = layoutOwnedMemberName(this.runId, key);
@@ -145,6 +146,8 @@ export class RoomLayoutService {
     }
     /** Reads only the named file, so an unrelated broken layout cannot block this one. */
     definition(name) {
+        if (name === EMPTY_TASK_LAYOUT)
+            return emptyTaskLayout();
         if (!validLayoutKey(name))
             throw Error(`room layout not found: ${name}`);
         const root = join(splitRootFor(this.configPath ?? defaultConfigPath()), 'room_layouts');

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

@@ -53,7 +53,7 @@ export interface LayoutSupervisor {
     id: string;
     /** Must verify current launch, CID, live session and standalone ownership. */
     verify(instance: LayoutInstance): Promise<void>;
-    spawn(key: string, template: string): Promise<LayoutInstance>;
+    spawn(key: string, template: string, definition?: import('../config.js').AgentTemplateDefinition): Promise<LayoutInstance>;
     join(instance: LayoutInstance, invite: string, roomCid: string, membership?: {
         roomId: string;
         role: string;
@@ -86,6 +86,14 @@ export interface RoomLayoutState {
     controller: string;
     participants: Record<string, ParticipantState>;
     rooms: Record<string, RoomState>;
+    /** Runtime additions leave the pinned source definition unchanged. */
+    additional_members?: Record<string, {
+        room: string;
+        role: string;
+        template: string;
+        request_id: string;
+        hash: string;
+    }>;
     order: string[];
     closed: boolean;
     closing?: boolean;
@@ -109,6 +117,15 @@ export declare class RoomLayout {
     private mutation;
     private activateRoom;
     activate(actor: string, key: string): Promise<void>;
+    /** Append an explicitly requested agent to an active owner-only room, with durable retry identity. */
+    addMember(actor: string, input: {
+        key: string;
+        room: string;
+        role: string;
+        requestId: string;
+        hash: string;
+        definition: import('../config.js').AgentTemplateDefinition;
+    }): Promise<void>;
     private assertRoomActive;
     private archiveRoom;
     closeRoom(actor: string, key: string): Promise<void>;

package/dist/rooms-tasks/layout.js

@@ -14,17 +14,20 @@ function need(ok, message) { if (!ok)
     throw Error(message); }
 /** Room/participant keys cannot contain ':', so scoped instance keys cannot collide. */
 function instanceKey(definition, participant, room) {
-    return definition.participants[participant].instance_scope === 'room' ? `${room}:${participant}` : participant;
+    return definition.participants[participant]?.instance_scope === 'room' ? `${room}:${participant}` : participant;
 }
 export function validateLayout(def) {
-    need(Object.keys(def.rooms).length && Object.keys(def.participants).length, 'rooms and participants required');
+    need(Object.keys(def.rooms).length, 'rooms required');
+    const empty = Object.keys(def.participants).length === 0;
+    if (empty)
+        need(Object.keys(def.rooms).length === 1, 'an empty layout requires exactly one room');
     for (const [key, participant] of Object.entries(def.participants)) {
         need(participant.instance_scope === undefined || ['layout', 'room'].includes(participant.instance_scope), `invalid instance_scope for ${key}`);
         if (participant.instance_scope === 'room')
             need(typeof participant.agent_template === 'string' && participant.agent_template.trim(), `room-scoped participant ${key} requires agent_template`);
     }
     for (const [key, room] of Object.entries(def.rooms)) {
-        need(key.length && room.goal.trim() && room.members.length, 'room goal and members required');
+        need(key.length && room.goal.trim() && (empty || room.members.length), 'room goal and members required');
         need(new Set(room.members).size === room.members.length, 'duplicate participant in room');
         for (const member of room.members)
             need(own(def.participants, member), `unknown participant ${member}`);
@@ -87,6 +90,8 @@ export class RoomLayout {
         });
     }
     checkOwnerRoles(definition) {
+        if (!Object.keys(definition.participants).length)
+            need(this.owner, 'an empty layout requires an attached room owner');
         if (!this.owner)
             return;
         for (const room of Object.values(definition.rooms))
@@ -113,6 +118,9 @@ export class RoomLayout {
         this.save(s);
     }
     async activateRoom(s, key, spec) {
+        const additions = Object.entries(s.additional_members ?? {}).filter(([, member]) => member.room === key);
+        spec = { ...spec, members: [...spec.members, ...additions.map(([name]) => name)],
+            roles: { ...spec.roles, ...Object.fromEntries(additions.map(([name, member]) => [name, member.role])) } };
         if (s.owner)
             need(this.owner && canonicalJson(s.owner) === canonicalJson(ownerReference(this.owner)), 'room owner configuration changed');
         this.checkOwnerRoles(s.definition);
@@ -129,15 +137,18 @@ export class RoomLayout {
             return;
         }
         const room = s.rooms[key] ??= { spec, state: 'provisioning', ready: [] };
+        room.spec = spec;
         this.save(s);
         for (const member of spec.members) {
             const resolvedKey = instanceKey(s.definition, member, key), p = s.participants[resolvedKey];
             if (!p.instance) {
-                const template = s.definition.participants[member]?.agent_template;
+                const template = s.definition.participants[member]?.agent_template ?? s.additional_members?.[member]?.template;
                 need(template, `no factory for ${member}`);
                 if (this.supervisor.taskSupervised)
                     p.task_supervised = true;
-                await this.mutation(s, `spawn:${resolvedKey}`, () => this.supervisor.spawn(resolvedKey, template), i => { p.instance = i; });
+                await this.mutation(s, `spawn:${resolvedKey}`, () => s.additional_members?.[member]
+                    ? this.supervisor.spawn(resolvedKey, template, s.agent_templates?.[template])
+                    : this.supervisor.spawn(resolvedKey, template), i => { p.instance = i; });
                 await this.verify(p.instance);
             }
         }
@@ -147,7 +158,8 @@ export class RoomLayout {
                 room_name: `${key.slice(0, 24)}-${createHash('sha256').update(this.file + '\0' + key).digest('hex').slice(0, 24)}`,
                 goal: spec.goal, briefing: JSON.stringify({ goal: spec.goal, contract: spec.contract }),
                 quiet_membership: spec.quiet_membership ?? true, anonymous: spec.anonymous ?? false,
-                activation_requirements: [...new Set(spec.members.map(roleFor))].map(role => ({ role, count: spec.members.filter(m => roleFor(m) === role).length })),
+                activation_requirements: !spec.members.length && s.owner ? [{ role: s.owner.role, count: 1 }]
+                    : [...new Set(spec.members.map(roleFor))].map(role => ({ role, count: spec.members.filter(m => roleFor(m) === role).length })),
             }), native => { room.native = native; s.order.push(key); });
         if (s.owner && !room.owner_ready)
             await this.mutation(s, `owner:${key}`, async () => {
@@ -188,6 +200,28 @@ export class RoomLayout {
             await this.activateRoom(s, key, s.definition.rooms[key]);
         });
     }
+    /** Append an explicitly requested agent to an active owner-only room, with durable retry identity. */
+    addMember(actor, input) {
+        return this.operation(actor, async (s) => {
+            need(!Object.keys(s.definition.participants).length, 'manual layout additions require an empty source layout');
+            need(/^[A-Za-z][A-Za-z0-9_-]{0,31}$/.test(input.key) && !['constructor', 'prototype', '__proto__'].includes(input.key), 'invalid member key');
+            need(s.owner && input.role !== s.owner.role, 'participant cannot use the owner role');
+            const existing = s.additional_members?.[input.key];
+            if (existing)
+                need(existing.request_id === input.requestId && existing.hash === input.hash, 'this member slot already exists');
+            else {
+                need(s.rooms[input.room]?.state === 'active', 'adding an agent requires an active layout room');
+                await this.assertRoomActive(s, input.room);
+                const template = `added-${input.key}`;
+                (s.additional_members ??= {})[input.key] = { room: input.room, role: input.role, template, request_id: input.requestId, hash: input.hash };
+                (s.agent_templates ??= {})[template] = structuredClone(input.definition);
+                s.participants[input.key] = { owned: true };
+                s.rooms[input.room].state = 'provisioning';
+                this.save(s);
+            }
+            await this.activateRoom(s, input.room, s.definition.rooms[input.room]);
+        });
+    }
     async assertRoomActive(s, key) {
         const room = s.rooms[key], native = await this.cowork.getRoom(room.native.room_id);
         need(native?.identity_cid === room.native.identity_cid && native.state === 'active', 'native room missing, changed or inactive');

package/dist/session/control.js

@@ -246,6 +246,7 @@ export class RoleControlServer {
                         version: 1, id: request.id, ok: true,
                         result: {
                             ...this.session.snapshot(),
+                            ownerChannelCid: this.ownerChannel?.ownerChannelCid?.(),
                             protocolVersion: this.session.conversationPage ? 3 : 2,
                             features: [
                                 'events_since', 'observer_follow', 'retained_range',

package/dist/web/server.js

@@ -1,6 +1,7 @@
 import { FleetResourceViews, ResourceBindingError, canonicalResourceDescriptor } from './resource-views.js';
 import { publishFleetResourceCommit } from '../application/resource-observer.js';
 import { stateRoot, defaultConfigPath } from '../paths.js';
+import { EMPTY_TASK_LAYOUT } from '../rooms-tasks/empty-layout.js';
 import { conversationPreview } from '../application/conversation-history.js';
 import { registerConversationStream } from './conversation-stream.js';
 import { conversationHasAttachment } from '../application/conversation-history.js';
@@ -561,9 +562,9 @@ export async function buildWebServer(services, boundary, options = {}) {
         const body = request.body;
         if (typeof body?.title !== 'string' || !body.title)
             throw new FleetError('invalid_request', 'title is required');
-        // Every task runs a saved Room Layout; rooms are never defined inline or from room templates here.
-        if (typeof body.layout !== 'string' || !body.layout)
-            throw new FleetError('invalid_request', 'layout is required: choose a room layout from Settings › Room layouts');
+        // Omission selects a real built-in layout, never a legacy no-room task.
+        if (body.layout !== undefined && (typeof body.layout !== 'string' || !body.layout))
+            throw new FleetError('invalid_request', 'layout must be a non-empty room layout name, or omitted for the empty layout');
         if (body.template !== undefined || body.noRoom !== undefined)
             throw new FleetError('invalid_request', 'tasks use room layouts; template and noRoom are not accepted');
         const task = await taskApi(() => requireTaskRooms().createTask({
@@ -571,7 +572,8 @@ export async function buildWebServer(services, boundary, options = {}) {
             brief: typeof body.brief === 'string' ? body.brief : undefined,
             backlog: body.backlog === true,
             list: typeof body.list === 'string' ? body.list : undefined,
-            layout: body.layout,
+            layout: body.layout === undefined ? EMPTY_TASK_LAYOUT : body.layout,
+            deferLayoutStart: true,
             idempotencyKey: typeof request.headers['idempotency-key'] === 'string'
                 ? request.headers['idempotency-key'] : undefined,
             origin: { type: 'web' },
@@ -748,7 +750,7 @@ export async function buildWebServer(services, boundary, options = {}) {
                         // A task's layout can be chosen or changed but never removed, so this check cannot go stale.
                         if (!api.getTask(taskId).task.layout)
                             throw new FleetError('conflict', 'choose a room layout for this task before starting it');
-                        const task = await api.startTask(input);
+                        const task = await api.startTask({ ...input, deferLayoutStart: true });
                         const provisioning = await api.launchTaskProvisioning(taskId);
                         if (provisioning.kind !== 'ready')
                             reply.code(202);

package/docs/room-layouts.md

@@ -3,6 +3,40 @@
 Room Layout describes room goals, participants and their shared or independent
 sessions. Rooms and agents have independent lifecycles.
 
+## Empty mission layout
+
+`POST /api/v1/tasks` may omit `layout`. Fleet then assigns the reserved built-in
+`builtin-empty` layout: one `mission` room and no agent participants. It is a real
+task layout with the usual pinned definition, private run snapshot, room ownership,
+and finish/cancel/delete cleanup. The built-in source cannot be edited or deleted;
+explicit saved-layout names select their configured rooms and participants.
+
+Starting this default mission creates its native room and admits the configured
+Owner CID before reporting Active. Starting a saved layout likewise initializes all
+its rooms and required agents automatically, in definition order. Shared
+participants are reused across their rooms. The HTTP request accepts startup
+promptly and a detached worker completes it; the task remains Provisioning until
+all rooms are ready. No agents are spawned. Owner attachment must be
+enabled and an Owner invite configured; an empty ownerless room is rejected.
+Saving with `backlog: true` creates no native room or agents until Start. Unknown
+native mutation outcomes retain the existing reconciliation marker and are not
+blindly replayed. Repeated requests with the same idempotency key reuse the task.
+
+An active built-in empty mission accepts agents later through
+`POST /api/v1/tasks/:id/members` and the existing durable member-addition receipt
+API. These explicit additions retain their own launch snapshots alongside the
+original empty definition. They use the mission workspace and existing agent
+ownership, admission, assignment and retirement checks. A repeated request ID
+observes the original receipt; an uncertain launch requires inspection, not a
+second automatic launch. The retained room-opening endpoint remains available for recovery of older
+active tasks whose rooms were declared but never initialized. New missions do not
+require a separate room-opening action.
+
+Layout YAML may also describe a single Owner room using `participants: {}` and
+`members: []`. Other layouts continue to require valid participant references.
+
+## Saved layouts
+
 Place a layout at `fleet/room_layouts/<name>.yaml` beside the split configuration
 for `fleet.yaml`. Agent Templates remain in `fleet/agent_templates/`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "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",