@ours.network/fleet 2.0.4 → 2.1.0

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/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "2.0.4",
-  "buildId": "26fbfdb783d8",
-  "commit": "b1e84b5fad5d06ca583aa5a9c1b45131fba62c6e",
+  "version": "2.1.0",
+  "buildId": "697e8bf9e53c",
+  "commit": "2805e0e84c2a3bad05efdbe895fd8fb6e9d2aff4",
   "dirty": false,
-  "builtAt": "2026-10-25T18:18:29.763Z",
+  "builtAt": "2026-10-27T12:22:22.859Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

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/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.4",
+  "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",