@ours.network/fleet 1.2.0-nightly.19 → 1.2.0-nightly.20

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

@@ -1,10 +1,12 @@
+import { TaskLayouts, assertLayoutOpenable, writeTaskBrief } from './task-layouts.js';
+import { FleetError } from './errors.js';
 import { readFileSync } from 'node:fs';
 import { taskLiveReadiness } from '../rooms-tasks/live-readiness.js';
 import { ConfigError, loadConfig } from '../config.js';
 import { CoworkProtocolError, CoworkUnavailableError, createCoworkAdapter, } from '../rooms-tasks/cowork-adapter.js';
 import { getBinPath, provisionMembers } from '../rooms-tasks/provision.js';
 import { activateRoom, advanceSaga, createRoomRecord, getRoomRecord, listRoomRecords, setOwnerSeat, setSagaError, } from '../rooms-tasks/room-state.js';
-import { activateTask, blockTask as persistBlockTask, createTask as persistTask, getDeletingTask, getTask as readTask, listTasks as readTasks, taskDeletionState, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, updateTaskExecutionPlan, } from '../rooms-tasks/task-state.js';
+import { activateTask, blockTask as persistBlockTask, createTask as persistTask, getDeletingTask, getTask as readTask, listTasks as readTasks, taskDeletionState, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, updateTaskExecutionPlan, updateTaskBrief, updateTaskLayout, } from '../rooms-tasks/task-state.js';
 import { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked, readTaskLists, renameTaskListLocked, resolveTaskList, TaskListError, withTaskListsLock, } from '../rooms-tasks/task-lists.js';
 import { hashTemplate, listTemplates, resolveTemplate, sealTemplateSnapshot, snapshotTemplate } from '../rooms-tasks/templates.js';
 import { acquireLaunchSnapshotLock, releaseLaunchSnapshot } from '../rooms-tasks/launch-snapshot.js';
@@ -72,7 +74,127 @@ export class TaskRoomApplicationService {
         this.configurationPath = configurationPath;
         this.deps = deps;
     }
+    async addMember(taskId, request) {
+        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 });
+    }
+    async memberAddition(taskId, requestId) { const { memberAddition } = await import('../rooms-tasks/add-member.js'); return memberAddition(taskId, requestId); }
+    layouts() {
+        return this.deps.taskLayouts ?? new TaskLayouts(this.configurationPath, { binPath: this.deps.binPath });
+    }
+    async createLayoutTask(request) {
+        if (request.template || request.noRoom || request.members || request.anonymous !== undefined)
+            throw new FleetError('invalid_request', 'a layout task cannot be combined with a room template, no-room mode, member overrides or anonymity');
+        let layout;
+        try {
+            layout = this.layouts().resolve(request.layout);
+        }
+        catch (error) {
+            throw new FleetError('invalid_request', error.message, { details: { layout: request.layout } });
+        }
+        const brief = request.briefFile ? readFileSync(request.briefFile, 'utf8') : request.brief;
+        const task = await withTaskListsLock(() => persistTask({
+            title: request.title, brief, brief_file: request.briefFile, layout,
+            origin: request.origin, idempotency_key: request.idempotencyKey,
+            start: !request.backlog, listId: resolveTaskList(request.list ?? 'default').list_id,
+        }));
+        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;
+    }
+    /** Layout tasks never provision the legacy single room; their run is a local snapshot. */
+    async ensureLayoutWork(task) {
+        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')
+            return { task, status: 'already_active' };
+        if (task.state === 'backlog') {
+            // Verify the pinned source before leaving Backlog, so a stale choice stays editable on the task page.
+            if (!this.layouts().runExists(task.layout) && this.layouts().resolve(task.layout.name).definition_hash !== task.layout.definition_hash)
+                throw new FleetError('conflict', `room layout ${task.layout.name} changed after it was chosen for this task; choose it again on the task page to use the edited version`);
+            task = transitionTask(task.task_id);
+        }
+        try {
+            await this.layouts().ensureRun(task);
+        }
+        catch (error) {
+            const reason = `layout run could not be created: ${error.message}`;
+            persistBlockTask(task.task_id, reason);
+            throw new FleetError('conflict', reason, { details: { task: task.task_id } });
+        }
+        return { task: activateTask(task.task_id), status: 'ready' };
+    }
+    /** Compact room list for task listings; never fails the listing on an unreadable run. */
+    withLayoutRooms(task) {
+        if (!task.layout)
+            return task;
+        try {
+            const view = this.layouts().view(task);
+            return { ...task, layout_rooms: (view?.rooms ?? []).map(({ key, state, room_id, identity_cid }) => ({ key, state, ...(room_id ? { room_id } : {}), ...(identity_cid ? { identity_cid } : {}) })) };
+        }
+        catch {
+            return { ...task, layout_rooms: [] };
+        }
+    }
+    /** Backlog only: choose, change or clear the task's Room Layout before it starts. */
+    async setTaskLayout(input) {
+        let next = null;
+        if (input.layout !== null) {
+            try {
+                next = this.layouts().resolve(input.layout);
+            }
+            catch (error) {
+                throw new FleetError('invalid_request', error.message, { details: { layout: input.layout } });
+            }
+        }
+        const current = readTask(input.taskId);
+        if (current.layout && this.layouts().runExists(current.layout))
+            throw new FleetError('conflict', 'this task already has a layout run; its room layout is fixed');
+        let result;
+        try {
+            result = updateTaskLayout(input.taskId, input.expectedLayout, next);
+        }
+        catch (error) {
+            if (error instanceof TaskStateError && !/task not found/.test(error.message))
+                throw new FleetError('conflict', error.message);
+            throw error;
+        }
+        // Only after the task stopped referencing it; release re-checks every retained reference under its lock.
+        if (result.releasedSnapshot)
+            releaseLaunchSnapshot(result.releasedSnapshot);
+        return result.task;
+    }
+    taskLayout(taskId) {
+        const task = readTask(taskId);
+        if (!task.layout)
+            throw new FleetError('resource_not_found', 'task has no room layout');
+        return this.layouts().view(task);
+    }
+    async launchTaskLayoutOperation(input) {
+        const task = readTask(input.taskId);
+        if (!task.layout)
+            throw new FleetError('resource_not_found', 'task has no room layout');
+        if (input.operation === 'open')
+            assertLayoutOpenable(task);
+        else if (task.deletion?.status === 'pending' || task.terminal_intent)
+            throw new FleetError('conflict', 'task is closing; its layout rooms are cleaned up by the terminal operation');
+        return this.layouts().launch(task, input.operation, input.room);
+    }
+    /** Worker entry for detached layout operations. */
+    async runTaskLayoutOperation(input) {
+        const task = readTask(input.taskId);
+        // Preconditions are enforced inside the worker before side effects; the worker is directly callable.
+        if (input.operation === 'open')
+            assertLayoutOpenable(task);
+        await this.layouts().run(task, input.operation, input.room, input.operationId);
+        return this.layouts().view(task);
+    }
     async createTask(request) {
+        if (request.layout !== undefined)
+            return this.createLayoutTask(request);
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let template = this.createTemplate(cfg, request.template, request.noRoom);
         if (request.noRoom && request.anonymous !== undefined)
@@ -220,16 +342,36 @@ export class TaskRoomApplicationService {
             return { deleted: source, moved: assigned.length, destination };
         });
     }
+    editTaskDescription(input) {
+        const task = updateTaskBrief(input.taskId, input.brief, input.expectedBrief);
+        // Layout rooms reference the brief file, so rooms opened later read the edited brief.
+        if (task.layout)
+            writeTaskBrief(task);
+        return task;
+    }
     getTask(taskId) {
-        const task = readTask(taskId);
+        const task = this.withLayoutRooms(readTask(taskId));
         return { task, orchestration: task.room_id ? getRoomRecord(task.room_id) : undefined };
     }
     /** Durable provisioning progress only; use active task start/work for a live readiness check. */
     taskProvisioningOutcome(taskId) {
         const task = readTask(taskId);
+        if (task.layout) {
+            const failed = task.state === 'failed';
+            const ready = ['active', 'review', 'done'].includes(task.state);
+            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 },
+                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}.` } : {}),
+            };
+        }
         const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
-        const expected = room?.template_snapshot?.members.reduce((sum, member) => sum + member.count, 0)
-            ?? task.execution_plan?.snapshot.members.reduce((sum, member) => sum + member.count, 0) ?? 0;
+        const expected = (room?.template_snapshot?.members.reduce((sum, member) => sum + member.count, 0)
+            ?? task.execution_plan?.snapshot.members.reduce((sum, member) => sum + member.count, 0) ?? 0)
+            + (room?.additional_member_templates ?? []).reduce((n, t) => n + t.members.reduce((m, s) => m + s.count, 0), 0);
         const active = room?.member_seats.filter(seat => seat.seat_state === 'active').length ?? 0;
         const launched = room?.member_seats.filter(seat => seat.launch?.state === 'launched').length ?? 0;
         const failed = task.state === 'failed' || room?.saga.phase === 'failed';
@@ -316,6 +458,15 @@ export class TaskRoomApplicationService {
     }
     /** Worker entry: converge an accepted deletion; Cowork is resolved lazily. */
     async settleTaskDeletion(input) {
+        // Layout resources close first; a failure stays a retryable pending deletion.
+        const deleting = (() => { try {
+            return getDeletingTask(input.taskId);
+        }
+        catch {
+            return undefined;
+        } })();
+        if (deleting?.layout)
+            await this.layouts().closeAndForget(deleting);
         const result = await settleTaskDeletion({
             taskId: input.taskId,
             cowork: () => {
@@ -344,7 +495,7 @@ export class TaskRoomApplicationService {
      */
     async launchTaskDeletionWorker(input) {
         const launch = this.deps.launchDeletionWorker
-            ?? ((taskId) => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, this.configurationPath));
+            ?? ((taskId) => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, this.configurationPath, this.deps.binPath?.()));
         const errorAtBefore = (() => {
             try {
                 return getDeletingTask(input.taskId).deletion?.error_at;
@@ -397,6 +548,20 @@ export class TaskRoomApplicationService {
         }
         return this.acceptTerminal(input.taskId, 'done', roomId, input.outcome);
     }
+    /** Terminal layout tasks archive their rooms and retire only agents their run created. */
+    async withLayoutCleanup(plan) {
+        // The task is already terminal; a worker launch failure is recorded on the run for retry.
+        if (plan.task.layout && this.layouts().runExists(plan.task.layout))
+            await this.layouts().launch(plan.task, 'close').catch(() => { });
+        return plan;
+    }
+    /** Retry terminal layout cleanup for known resources (e.g. after a failed close). */
+    async retryTaskLayoutCleanup(input) {
+        const task = readTask(input.taskId);
+        if (!task.layout || !TASK_TERMINAL_STATES.includes(task.state))
+            throw new TaskStateError('layout cleanup applies to finished or cancelled layout tasks');
+        return this.layouts().launch(task, 'close');
+    }
     async cancelTask(input) {
         const task = readTask(input.taskId);
         if (!TASK_CANCELLABLE_STATES.includes(task.state))
@@ -405,6 +570,23 @@ export class TaskRoomApplicationService {
             (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return this.acceptTerminal(input.taskId, 'cancelled', task.room_id);
     }
+    /** Continue accepted operations outside the HTTP connection's lifetime. */
+    async launchTaskSettlement(taskId) {
+        try {
+            await launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, this.configurationPath, this.deps.binPath?.());
+        }
+        catch (error) {
+            await recordTaskTerminalIntentError(taskId, error instanceof Error ? error.message : String(error), 'The settlement worker could not start. Inspect the task before retrying.');
+        }
+        return readTask(taskId);
+    }
+    async launchTaskProvisioning(taskId) {
+        const outcome = this.taskProvisioningOutcome(taskId);
+        if (outcome.kind === 'in_progress' && !outcome.next_action) {
+            await launchFleetWorker(['task', '_provision', taskId], `task-provision-${taskId}`, this.configurationPath, this.deps.binPath?.());
+        }
+        return outcome;
+    }
     async settleTask(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         if (!cfg.rooms)
@@ -500,7 +682,7 @@ export class TaskRoomApplicationService {
                 throw new ConfigError('rooms: configuration is required before creating or querying rooms');
             const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
             await (this.deps.provisionMembers ?? provisionMembers)({
-                cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
+                configPath: this.configurationPath, cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
                 binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief, goal: task.title,
             });
             task = readTask(task.task_id);
@@ -563,7 +745,8 @@ export class TaskRoomApplicationService {
     }
     async acceptTerminal(taskId, kind, roomId, outcome) {
         const task = await acceptTaskTerminalIntent({ taskId, kind, roomId, outcome });
-        return { task, settlementRequired: task.terminal_intent?.status === 'pending' && !!roomId };
+        // Every terminal path (complete, finish, cancel) closes a layout task's rooms.
+        return this.withLayoutCleanup({ task, settlementRequired: task.terminal_intent?.status === 'pending' && !!roomId });
     }
     listTemplates() {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
@@ -694,6 +877,11 @@ export class TaskRoomApplicationService {
     async ensureTaskWork(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let task = readTask(input.taskId);
+        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);
+        }
         const recordedRoom = task.room_id ? getRoomRecord(task.room_id) : undefined;
         const recordedPolicy = storedRoomLaunchPolicy(recordedRoom?.room_policy ?? task.execution_plan?.room_policy);
         if (task.room_id && input.anonymous !== undefined && input.anonymous !== recordedPolicy.anonymous)
@@ -858,7 +1046,7 @@ export class TaskRoomApplicationService {
                 if (!cfg.rooms)
                     throw new ConfigError('rooms: configuration is required before creating or querying rooms');
                 const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
-                await (this.deps.provisionMembers ?? provisionMembers)({ cfg, cowork, roomId: room.room_id,
+                await (this.deps.provisionMembers ?? provisionMembers)({ configPath: this.configurationPath, cfg, cowork, roomId: room.room_id,
                     taskId: task.task_id, template: snapshot, binPath: (this.deps.binPath ?? getBinPath)(),
                     brief: task.brief, goal: task.title });
                 task = readTask(task.task_id);
@@ -1004,7 +1192,7 @@ export class TaskRoomApplicationService {
         if (launchTemplate && (launchTemplate.members.length > 0 || attachOwner))
             try {
                 room = await (this.deps.provisionMembers ?? provisionMembers)({
-                    cfg, cowork, roomId: room.room_id, taskId: task.task_id, template: launchTemplate,
+                    configPath: this.configurationPath, cfg, cowork, roomId: room.room_id, taskId: task.task_id, template: launchTemplate,
                     binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief,
                     goal: task.task_id ? task.title : task.goal,
                 });

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.19",
-  "buildId": "1175f8bb300d",
-  "commit": "3872302b8c5bd5f427ad798df3883262a8928554",
+  "version": "1.2.0-nightly.20",
+  "buildId": "bd038efa768e",
+  "commit": "5f7b870fe2d026aeadb508a13c6dbdc38f573d2c",
   "dirty": true,
-  "builtAt": "2026-09-27T11:02:00.743Z",
+  "builtAt": "2026-09-29T18:01:53.344Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/cli.js

@@ -47,6 +47,7 @@ import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCliExit, s
 import './harness/claude-code.js'; // registers the claude-code adapter
 import './harness/codex.js'; // registers the codex adapter
 import './harness/hermes.js';
+import { registerLayoutCommands } from './rooms-tasks/layout-cli.js';
 import { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './rooms-tasks/cli.js';
 import { RoleCreationService } from './application/role-creation-service.js';
 import { RoleRemovalService } from './application/role-removal-service.js';
@@ -1577,6 +1578,7 @@ function configureWebAccess(opts) {
     return undefined;
 }
 // ── rooms & tasks ──────────────────────────────────────────────────────────
+registerLayoutCommands(program, cOpt);
 registerTemplateCommands(program, cOpt);
 registerTaskCommands(program, cOpt);
 registerRoomCommands(program, cOpt);

package/dist/config.d.ts

@@ -2,6 +2,7 @@ import { type ConfigDiagnostic, type YamlMode } from './config-yaml.js';
 import type { IsolationConfig, WrapContext } from './isolation/types.js';
 import type { ResolvedWatchdog } from './watchdog/config.js';
 import type { AgentLoopsConfig, ResolvedLoop, ResolvedRoleLoop } from './loops/config.js';
+import { validateRoomsConfig } from './rooms-tasks/config.js';
 export interface OverseeEntry {
     agent: string;
     interval: string;
@@ -299,6 +300,8 @@ export declare function validateBrainValue(value: BarePreset, file: string, poin
 export declare function validateEffectiveAgentTemplate(definition: AgentTemplateDefinition, id?: string): AgentTemplateDefinition;
 export declare function assertBareKeys(value: unknown, allowed: string[], label: string): BarePreset;
 export declare function splitRootFor(base: string): string;
+/** Read only room connection/owner settings for an existing layout. */
+export declare function loadRoomsConfig(configPath?: string): ReturnType<typeof validateRoomsConfig>;
 /** Load a v2 manifest and bare Agent/Role/Brain documents from its stem directory. */
 export declare function loadConfig(configPath?: string, options?: {
     yamlMode?: YamlMode;

package/dist/config.js

@@ -575,6 +575,13 @@ function deepSub(v, vars) {
         return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, deepSub(x, vars)]));
     return v;
 }
+/** Read only room connection/owner settings for an existing layout. */
+export function loadRoomsConfig(configPath = defaultConfigPath()) {
+    assertTrustedPath(configPath, 'file');
+    const doc = parseFleetDocument(configPath, readFileSync(configPath, 'utf8')).value;
+    const vars = (doc.vars ?? {});
+    return validateRoomsConfig(deepSub(doc.rooms, vars), vars, configPath);
+}
 /** Load a v2 manifest and bare Agent/Role/Brain documents from its stem directory. */
 export function loadConfig(configPath, options = {}) {
     const base = configPath ?? defaultConfigPath();

package/dist/init-wizard.js

@@ -244,8 +244,10 @@ export function generateSetup(answers) {
     }
     files.set('agents/FleetCoordinator.yaml', preset('agents/FleetCoordinator.yaml')
         .replace('brain: { ref: claude-default }', 'brain: { ref: coordination }'));
-    for (const name of ['single', 'pair', 'team', 'engineering'])
+    for (const name of ['single', 'pair', 'team', 'engineering']) {
         files.set(`room_templates/${name}.yaml`, preset(`room_templates/${name}.yaml`));
+        files.set(`room_layouts/${name}.yaml`, preset(`room_layouts/${name}.yaml`));
+    }
     return { files, answers };
 }
 /** Run the mutation boundary only after the complete questionnaire is accepted. */
@@ -393,7 +395,7 @@ function writeStaged(stageManifest, setup) {
         replaceFileAtomically(target, contents, 0o600);
         fsyncPath(target);
     }
-    for (const kind of ['agents', 'agent_templates', 'roles', 'brains', 'room_templates'])
+    for (const kind of ['agents', 'agent_templates', 'roles', 'brains', 'room_templates', 'room_layouts'])
         fsyncPath(join(stageRoot, kind));
     fsyncPath(stageRoot);
     fsyncPath(dirname(stageManifest));

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

@@ -0,0 +1,48 @@
+import type { FleetConfig } from '../config.js';
+import { TaskStateError } from './task-state.js';
+import { provisionMembers } from './provision.js';
+import type { CoworkAdapter } from './cowork-adapter.js';
+export declare class MemberAdditionRejected extends TaskStateError {
+    readonly accepted = false;
+}
+export interface AddMemberRequest {
+    requestId: string;
+    slot: string;
+    role: string;
+    brain: string;
+    agentTemplate: string;
+}
+export declare function memberAddition(taskId: string, requestId: string): {
+    requestId: string;
+    taskId: string;
+    roleId: string;
+    state: "running" | "succeeded" | "attention" | "failed";
+    error?: string;
+} | {
+    state: string;
+    error: string;
+    requestId: string;
+    taskId: string;
+    roleId: string;
+};
+export declare function requestMemberAddition(input: {
+    taskId: string;
+    request: AddMemberRequest;
+    cfg: FleetConfig;
+    cowork: CoworkAdapter;
+    configPath?: string;
+    binPath: string;
+    provision?: typeof provisionMembers;
+}): Promise<{
+    requestId: string;
+    taskId: string;
+    roleId: string;
+    state: "running" | "succeeded" | "attention" | "failed";
+    error?: string;
+} | {
+    state: string;
+    error: string;
+    requestId: string;
+    taskId: string;
+    roleId: string;
+}>;

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

@@ -0,0 +1,83 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { canonicalJson } from '../canonical-json.js';
+import { stateRoot } from '../paths.js';
+import { getTask, TaskStateError } from './task-state.js';
+import { getRoomRecord } from './room-state.js';
+import { prepareExecutionPlan } from './member-overrides.js';
+import { sealTemplateSnapshot } from './templates.js';
+import { provisionMembers } from './provision.js';
+export class MemberAdditionRejected extends TaskStateError {
+    accepted = false;
+}
+const running = new Set();
+function pathFor(taskId, requestId) {
+    if (!/^[a-z0-9]{10,40}$/.test(taskId) || !/^[a-zA-Z0-9_-]{8,80}$/.test(requestId))
+        throw new TaskStateError('Invalid task or request ID');
+    return join(stateRoot(), 'member-additions', taskId, requestId + '.json');
+}
+export function memberAddition(taskId, requestId) {
+    getTask(taskId);
+    const path = pathFor(taskId, requestId);
+    if (!existsSync(path))
+        throw new TaskStateError('Member request not found');
+    const receipt = JSON.parse(readFileSync(path, 'utf8'));
+    const { hash, ...view } = receipt;
+    return receipt.state === 'running' && !running.has(path) ? { ...view, state: 'attention', error: 'The server stopped observing this launch. Inspect the existing agent before any recovery.' } : view;
+}
+export async function requestMemberAddition(input) {
+    const { request: r, taskId } = input;
+    if (!r || typeof r.slot !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]{0,31}$/.test(r.slot)
+        || ![r.role, r.brain, r.agentTemplate].every(v => typeof v === 'string' && v.length > 0 && v.length <= 128))
+        // No receipt lookup has happened yet: this request ID may already be accepted.
+        throw new TaskStateError('Slot, Role, Brain and Agent Template are required');
+    const path = pathFor(taskId, r.requestId);
+    const hash = createHash('sha256').update(canonicalJson(r)).digest('hex');
+    mkdirSync(join(stateRoot(), 'member-additions', taskId), { recursive: true, mode: 0o700 });
+    return withFileLock(path + '.lock', async () => {
+        if (existsSync(path)) {
+            const old = JSON.parse(readFileSync(path, 'utf8'));
+            if (old.hash !== hash)
+                throw new TaskStateError('Request ID was already used with different settings');
+            return memberAddition(taskId, r.requestId);
+        }
+        const task = getTask(taskId);
+        const room = task.room_id && getRoomRecord(task.room_id);
+        if (!room || !['active', 'review'].includes(task.state) || task.terminal_intent || task.blocked || room.state !== 'active'
+            || room.task_id !== taskId || room.room_identity_cid !== task.room_identity_cid)
+            throw new MemberAdditionRejected('Adding an agent requires an active, unblocked task room');
+        const roleId = `${taskId.slice(0, 8)}-${r.slot}-1`;
+        if (room.member_seats.some(s => s.role_name === roleId))
+            throw new MemberAdditionRejected('This member slot already exists');
+        const plan = (() => {
+            try {
+                return prepareExecutionPlan({ name: 'additional-member', version: 1, description: 'Additional task participant',
+                    contract: room.template_snapshot?.contract, members: [{ slot: r.slot, role: r.role, count: 1, agent_template: r.agentTemplate }] }, input.cfg, { [r.slot]: { role: r.role, brain: r.brain } });
+            }
+            catch (error) {
+                throw new MemberAdditionRejected(error instanceof Error ? error.message : 'Invalid member configuration');
+            }
+        })();
+        const template = sealTemplateSnapshot(plan.snapshot, input.cfg.agentTemplates ?? {}, plan.launchDefinitions);
+        const receipt = { taskId, requestId: r.requestId, roleId, hash, state: 'running' };
+        const save = () => replaceFileAtomically(path, JSON.stringify(receipt) + '\n', 0o600);
+        save();
+        running.add(path);
+        void (input.provision ?? provisionMembers)({ cfg: input.cfg, cowork: input.cowork, configPath: input.configPath, binPath: input.binPath,
+            taskId, roomId: room.room_id, template, goal: task.title, brief: task.brief, append: true }).then(result => {
+            const seat = result.member_seats.find(s => s.role_name === roleId);
+            receipt.state = seat?.seat_state === 'active' && getTask(taskId).member_roles.some(m => m.name === roleId) ? 'succeeded' : 'attention';
+            if (receipt.state === 'attention')
+                receipt.error = 'Admission is not confirmed. Inspect the existing launch; no automatic retry was made.';
+        }).catch(() => { receipt.state = 'failed'; receipt.error = 'Member launch failed. Inspect the task and agent logs before recovery.'; })
+            .finally(() => { try {
+            save();
+        }
+        finally {
+            running.delete(path);
+        } }).catch(() => { running.delete(path); });
+        return memberAddition(taskId, r.requestId);
+    });
+}

package/dist/rooms-tasks/cli.js

@@ -1185,6 +1185,26 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    cOpt(taskCmd.command('_layout <id> <operation> [room]', { hidden: true }))
+        .description('internal: run an accepted layout room operation (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))
+                throw new Error(`unknown layout operation: ${operation}`);
+            const view = await taskRoomService(opts.configuration).runTaskLayoutOperation({
+                actor: { kind: 'internal_worker', surface: 'cli' }, taskId: id,
+                operation: operation, room, operationId: opts.operationId,
+            });
+            console.log(JSON.stringify({ schema_version: 1, layout: view }, null, 2));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     cOpt(taskCmd.command('_settle_delete <id>', { hidden: true }))
         .description('internal: settle a previously accepted task deletion')
         .option('--json', 'JSON output')

package/dist/rooms-tasks/external-worker.d.ts

@@ -8,4 +8,4 @@ export declare function presentFleetWorkerLifecycle(presentations: FleetAuditPre
     sleep(ms: number): Promise<void>;
 }): Promise<void>;
 /** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
-export declare function launchFleetWorker(args: string[], operation: string, configPath?: string): Promise<void>;
+export declare function launchFleetWorker(args: string[], operation: string, configPath?: string, binPath?: string): Promise<void>;

package/dist/rooms-tasks/external-worker.js

@@ -9,7 +9,7 @@ const LIFECYCLE_ACCEPT_TIMEOUT_MS = 10 * 60_000;
 const LIFECYCLE_RETRY_MS = 250;
 export function fleetWorkerEnv(source = process.env) {
     const inheritedKeys = [
-        'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_CONFIG',
+        'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_FLEET_SOCKET_ROOT', 'OURS_CONFIG',
     ];
     const env = Object.fromEntries(inheritedKeys.flatMap(key => source[key] === undefined ? [] : [[key, source[key]]]));
     const lifecycleStateDir = source[FLEET_WORKER_LIFECYCLE_STATE_DIR_ENV]
@@ -51,8 +51,8 @@ export async function presentFleetWorkerLifecycle(presentations, deps = {
     }
 }
 /** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
-export function launchFleetWorker(args, operation, configPath) {
-    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+export function launchFleetWorker(args, operation, configPath, binPath = process.argv[1]) {
+    const cli = [binPath, ...args, ...(configPath ? ['-c', configPath] : [])];
     const env = fleetWorkerEnv();
     const inherited = Object.entries(env).map(([key, value]) => `${key}=${value}`);
     const suffix = randomUUID().slice(0, 8);

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLayoutCommands(parent: Command, cOpt: (cmd: Command) => Command): void;