@ours.network/fleet 1.2.0-nightly.6 → 1.2.0-nightly.61

package/dist/rooms-tasks/legacy-task-member.js

@@ -0,0 +1,116 @@
+import { lstatSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { parse, stringify } from 'yaml';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { binderKey } from '../agent-ours/state.js';
+import { readClientProfile } from '../client-profile.js';
+import { readProvenance } from '../creation.js';
+import { agentDir, stateRoot } from '../paths.js';
+import { readTempSupervisor, tempSupervisorLiveness, TEMP_SUPERVISOR_FILE } from '../temp-lifecycle.js';
+import { getTask } from './task-state.js';
+import { getRoomRecord, updateMemberStartup } from './room-state.js';
+import { assertMemberNotPermanent } from './member-ownership.js';
+function bounded(path) {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 256 * 1024)
+        throw Error('LEGACY_TASK_MEMBER_UNSAFE_PROOF');
+    return readFileSync(path, 'utf8');
+}
+async function verifyIdentity(name, cid, env) {
+    const profile = readClientProfile(env);
+    const client = await attachOursClient({ endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+        credentialPath: profile.credentialPath, sessionMode: 'external', env: {}, leaseToken: `task-migration-${randomUUID()}` });
+    try {
+        const identities = await client.listIdentities();
+        const found = identities.find(value => value.name === name);
+        if (!found || !('cid' in found) || found.cid.toLowerCase() !== cid.toLowerCase())
+            throw Error('LEGACY_TASK_MEMBER_IDENTITY_MISMATCH');
+    }
+    finally {
+        try {
+            await client.releaseLease();
+        }
+        finally {
+            await client.close();
+        }
+    }
+}
+/** Caller holds task and room operation locks. No service is started here.
+ * Running legacy supervisors remain untouched; stopped exact state receives
+ * only ownership metadata, preserving launch, identity and conversation.
+ */
+export async function adoptLegacyTaskMember(owner, name, deps = {}) {
+    return withFileLock(join(stateRoot(), 'locks', 'temp-supervisors', encodeURIComponent(name)), async () => {
+        assertMemberNotPermanent(name);
+        const dir = agentDir(name, true), task = getTask(owner.taskId), room = getRoomRecord(owner.roomId);
+        const seat = room?.member_seats.find(value => value.role_name === name);
+        const supervisor = readTempSupervisor(dir);
+        const rolePath = join(dir, 'role.yaml'), roleBytes = bounded(rolePath);
+        const role = parse(roleBytes);
+        const startup = role?.roomMemberStartup, provenance = readProvenance(dir);
+        if (task.deletion || task.terminal_intent || !['provisioning', 'active', 'review'].includes(task.state)
+            || !room || room.close || !['provisioning', 'active'].includes(room.state) || room.task_id !== owner.taskId
+            || task.room_id !== owner.roomId || room.room_identity_cid !== owner.roomIdentityCid
+            || task.room_identity_cid !== owner.roomIdentityCid || !seat || seat.retirement
+            || !supervisor || supervisor.role !== name || seat.launch?.launch_id !== supervisor.launchId
+            || seat.launch.action_id !== owner.creationActionId || provenance?.creationActionId !== owner.creationActionId
+            || provenance.role !== name || role.name !== name || role.identity !== name
+            || startup?.identity_name !== name || startup.room_id !== owner.roomId
+            || startup.room_identity_cid !== owner.roomIdentityCid || startup.invite_id !== seat.invite_id
+            || startup.role !== seat.cowork_role || startup.invite !== ''
+            || (startup.task_id !== undefined && startup.task_id !== owner.taskId)
+            || (room.workspace && (role.cwd !== room.workspace.path || JSON.stringify(startup.workspace) !== JSON.stringify(room.workspace)))
+            || bounded(join(dir, '.identity')).trim() !== name)
+            throw Error('LEGACY_TASK_MEMBER_OWNERSHIP_MISMATCH');
+        if (supervisor.taskOwner) {
+            if (Object.entries(owner).some(([key, value]) => supervisor.taskOwner[key] !== value)
+                || startup.task_id !== owner.taskId)
+                throw Error('LEGACY_TASK_MEMBER_OWNER_MISMATCH');
+            if (supervisor.kind !== 'detached' && process.env.OURS_FLEET_SUPERVISOR !== 'none')
+                updateMemberStartup(owner.roomId, name, { launch: { ...seat.launch, task_supervised: true } });
+            return 'already-durable';
+        }
+        const live = await (deps.liveness ?? tempSupervisorLiveness)(dir);
+        if (live === 'running')
+            return 'running-legacy';
+        if (live !== 'stopped')
+            throw Error('LEGACY_TASK_MEMBER_LIVENESS_UNKNOWN');
+        const env = { ...process.env, ...role.env };
+        const profile = readClientProfile(env);
+        const privateDir = join(stateRoot(), 'private-ours', binderKey(profile.expectedInstanceId, name));
+        const state = JSON.parse(bounded(join(privateDir, 'state.json')));
+        const instance = JSON.parse(bounded(join(privateDir, 'instance.json')));
+        const externalOwner = JSON.parse(bounded(join(privateDir, 'owner.json')));
+        const launch = JSON.parse(bounded(join(stateRoot(), 'private-ours', 'launches', binderKey('temporary', name) + '.json')));
+        if (!seat.identity_cid || state.name !== name || state.daemon !== profile.expectedInstanceId
+            || state.lifetime !== 'temporary' || state.action !== owner.creationActionId
+            || state.cid?.toLowerCase() !== seat.identity_cid.toLowerCase()
+            || !['READY', 'SERVING', 'RECOVERING'].includes(state.phase)
+            || instance.role !== name || instance.temporary !== true || instance.instance !== state.instance
+            || externalOwner.instance !== state.instance || typeof externalOwner.token !== 'string' || !externalOwner.token
+            || state.room?.id !== owner.roomId || state.room.cid !== owner.roomIdentityCid
+            || state.room.agentCid.toLowerCase() !== seat.identity_cid.toLowerCase() || state.room.action !== seat.invite_id
+            || launch.role !== name || launch.identity !== name || launch.action !== owner.creationActionId)
+            throw Error('LEGACY_TASK_MEMBER_RUNTIME_NOT_RESUMABLE');
+        const sessionPath = join(dir, role.session === 'codex-app-server' ? '.session-id' : '.acp-session-id');
+        if (!bounded(sessionPath).trim())
+            throw Error('LEGACY_TASK_MEMBER_CONVERSATION_MISSING');
+        if (deps.verifyIdentity)
+            await deps.verifyIdentity(name, seat.identity_cid);
+        else
+            await verifyIdentity(name, seat.identity_cid, env);
+        assertMemberNotPermanent(name);
+        if (bounded(rolePath) !== roleBytes || JSON.stringify(readTempSupervisor(dir)) !== JSON.stringify(supervisor))
+            throw Error('LEGACY_TASK_MEMBER_STATE_CHANGED');
+        // Crash after this write is healed by retrying the same stopped adoption.
+        startup.task_id = owner.taskId;
+        replaceFileAtomically(rolePath, stringify(role));
+        if (supervisor.kind !== 'detached' && process.env.OURS_FLEET_SUPERVISOR !== 'none')
+            updateMemberStartup(owner.roomId, name, { launch: { ...seat.launch, task_supervised: true } });
+        deps.beforeOwnerCommit?.();
+        replaceFileAtomically(join(dir, TEMP_SUPERVISOR_FILE), JSON.stringify({ ...supervisor, taskOwner: owner }, null, 2) + '\n');
+        return 'adopted';
+    });
+}

package/dist/rooms-tasks/live-readiness.d.ts

@@ -0,0 +1,18 @@
+import { readRoomReadiness } from '../agent-ours/service.js';
+import { controlRequest } from '../session/control.js';
+import { readTempSupervisor, tempSupervisorLiveness } from '../temp-lifecycle.js';
+import type { CoworkAdapter } from './cowork-adapter.js';
+import type { RoomOrchestrationRecord, TaskRecord } from './types.js';
+export type TaskReadinessIssue = {
+    state: 'degraded' | 'unknown';
+    reason: string;
+    member?: string;
+};
+export interface LiveReadinessDeps {
+    supervisor?: typeof readTempSupervisor;
+    liveness?: typeof tempSupervisorLiveness;
+    readiness?: typeof readRoomReadiness;
+    control?: typeof controlRequest;
+}
+/** Read-only observation. A failed probe never grants authority to replace a seat. */
+export declare function taskLiveReadiness(task: TaskRecord, room: RoomOrchestrationRecord | undefined, cowork: Pick<CoworkAdapter, 'getRoom'>, deps?: LiveReadinessDeps): Promise<TaskReadinessIssue | undefined>;

package/dist/rooms-tasks/live-readiness.js

@@ -0,0 +1,85 @@
+import { realExec } from '../exec.js';
+import { agentDir } from '../paths.js';
+import { readRoomReadiness } from '../agent-ours/service.js';
+import { controlRequest } from '../session/control.js';
+import { readTempSupervisor, tempSupervisorLiveness } from '../temp-lifecycle.js';
+/** Read-only observation. A failed probe never grants authority to replace a seat. */
+export async function taskLiveReadiness(task, room, cowork, deps = {}) {
+    const degraded = (reason, member) => ({ state: 'degraded', reason, member });
+    const unknown = (reason, member) => ({ state: 'unknown', reason, member });
+    if (!room || task.state !== 'active' || task.room_id !== room.room_id || room.state !== 'active' || room.close || task.terminal_intent
+        || room.task_id !== task.task_id || !room.room_identity_cid
+        || task.room_identity_cid !== room.room_identity_cid)
+        return degraded('room_record_mismatch');
+    const baseExpected = room.template_snapshot?.members.reduce((n, member) => n + member.count, 0);
+    const expected = baseExpected === undefined ? undefined : baseExpected + (room.additional_member_templates ?? []).reduce((n, t) => n + t.members.reduce((m, s) => m + s.count, 0), 0);
+    if (expected === undefined || room.member_seats.length !== expected
+        || new Set(room.member_seats.map(seat => seat.role_name)).size !== expected
+        || new Set(room.member_seats.map(seat => seat.identity_cid)).size !== expected)
+        return degraded('member_roster_mismatch');
+    let remote;
+    try {
+        remote = await cowork.getRoom(room.room_id);
+    }
+    catch {
+        return unknown('room_probe_unavailable');
+    }
+    if (!remote || remote.room_id !== room.room_id || remote.identity_cid !== room.room_identity_cid
+        || remote.state !== 'active')
+        return degraded('room_identity_or_state_mismatch');
+    if (room.owner_seat_cid && remote.seats.filter(seat => seat.identity_cid.toLowerCase() === room.owner_seat_cid.toLowerCase() && seat.seat_state === 'active').length !== 1)
+        return degraded('owner_seat_missing');
+    for (const seat of room.member_seats) {
+        const member = seat.role_name;
+        if (!/^[A-Za-z0-9_-]+$/.test(member) || seat.seat_state !== 'active' || !seat.identity_cid || !seat.invite_id
+            || seat.launch?.state !== 'launched' || !seat.launch.launch_id || seat.retirement)
+            return degraded('member_record_incomplete', member);
+        const matches = remote.seats.filter(item => item.display_name === member && item.seat_state !== 'removed');
+        if (matches.length !== 1 || matches[0].identity_cid !== seat.identity_cid
+            || matches[0].invite_id !== seat.invite_id || matches[0].role !== seat.cowork_role
+            || matches[0].seat_state !== 'active')
+            return degraded('member_seat_mismatch', member);
+        const dir = agentDir(member, true);
+        try {
+            const supervisor = (deps.supervisor ?? readTempSupervisor)(dir);
+            if (!supervisor)
+                return unknown('supervisor_record_missing', member);
+            if (supervisor.role !== member || supervisor.launchId !== seat.launch.launch_id)
+                return degraded('supervisor_launch_mismatch', member);
+            const live = await (deps.liveness ?? tempSupervisorLiveness)(dir, {
+                exec: (cmd, args, opts) => realExec(cmd, args, { ...opts, timeout: 2_000 }),
+            });
+            if (live === 'stopped')
+                return degraded('supervisor_stopped', member);
+            if (live !== 'running')
+                return unknown('supervisor_liveness_unknown', member);
+            const ready = (deps.readiness ?? readRoomReadiness)(room.room_identity_cid, member);
+            if (!ready || ready.room !== room.room_id || ready.invite !== seat.invite_id || ready.cid !== seat.identity_cid)
+                return degraded('member_readiness_mismatch', member);
+        }
+        catch {
+            return unknown('supervisor_probe_unavailable', member);
+        }
+        try {
+            const response = await (deps.control ?? controlRequest)(dir, { command: 'status', controller: false }, 2_000);
+            if (!response.ok)
+                return unknown('control_unavailable', member);
+            const status = response.result;
+            if (status?.alive === false || status?.readiness === 'failed')
+                return degraded('agent_not_ready', member);
+            if (status?.alive !== true || !['idle', 'running', 'awaiting_permission'].includes(status.readiness ?? ''))
+                return unknown('agent_readiness_unknown', member);
+            const after = (deps.supervisor ?? readTempSupervisor)(dir);
+            if (!after || after.role !== member || after.launchId !== seat.launch.launch_id)
+                return degraded('supervisor_launch_changed', member);
+        }
+        catch {
+            return unknown('control_unavailable', member);
+        }
+    }
+    const memberCids = new Set(room.member_seats.map(seat => seat.identity_cid));
+    const memberRoles = new Set(room.member_seats.map(seat => seat.cowork_role));
+    if (remote.seats.some(seat => seat.seat_state === 'active' && memberRoles.has(seat.role)
+        && !memberCids.has(seat.identity_cid) && seat.identity_cid.toLowerCase() !== room.owner_seat_cid?.toLowerCase()))
+        return degraded('untracked_member_seats');
+}

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

@@ -0,0 +1,5 @@
+/** A room seat is never authority to retire a standalone persistent agent.
+ * Check both role-name collisions and a permanent role using the seat's
+ * identity name. Missing legacy task state must not bypass this fence.
+ */
+export declare function assertMemberNotPermanent(name: string): void;

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

@@ -0,0 +1,40 @@
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentDir, agentsRoot } from '../paths.js';
+/** A room seat is never authority to retire a standalone persistent agent.
+ * Check both role-name collisions and a permanent role using the seat's
+ * identity name. Missing legacy task state must not bypass this fence.
+ */
+export function assertMemberNotPermanent(name) {
+    if (!/^[a-zA-Z0-9_-]{1,120}$/.test(name))
+        throw new Error('Invalid retirement member name');
+    if (existsSync(agentDir(name)))
+        throw new Error(`room member '${name}' conflicts with permanent agent state; refusing retirement`);
+    let entries;
+    try {
+        entries = readdirSync(agentsRoot(), { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.isSymbolicLink())
+            continue;
+        const path = join(agentsRoot(), entry.name, '.identity');
+        let stat;
+        try {
+            stat = lstatSync(path);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024)
+            throw new Error('Permanent identity ownership proof is unsafe; refusing member retirement');
+        if (readFileSync(path, 'utf8').trim() === name)
+            throw new Error(`room member '${name}' identity belongs to permanent agent '${entry.name}'; refusing retirement`);
+    }
+}

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

@@ -6,6 +6,7 @@ export interface RoomTaskMember {
 }
 /** Build the complete task text Fleet places directly in a temporary member's briefing. */
 export declare function buildRoomMemberTask(input: {
+    workspace?: string;
     taskId?: string;
     roomId: string;
     roomIdentityCid: string;

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

@@ -7,6 +7,8 @@ export function buildRoomMemberTask(input) {
         `Fleet Task ${input.taskId ?? '(standalone)'} — ${member.cowork_role} in room ${input.roomId}`,
         '',
     ];
+    if (input.workspace)
+        lines.push(`Task-owned workspace: ${input.workspace}`, 'Start and keep all execution artifacts, dependency checkouts, and Git worktrees inside this workspace.', 'Clone repositories inside this workspace before adding worktrees; never attach to an external Git common directory.', 'Use distinct per-agent branches/directories for concurrent edits. Configured cwd is source context, not artifact ownership.', 'Completion, cancellation and room retirement retain artifacts. Only explicit owner deletion removes them.', 'Do not delete the workspace or its ownership marker yourself.', '');
     if (input.goal)
         lines.push(`Goal: ${input.goal}`);
     if (input.brief)

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

@@ -3,6 +3,7 @@ import type { RoomOrchestrationRecord, TemplateSnapshot } from './types.js';
 import { type FleetConfig } from '../config.js';
 export declare function getBinPath(): string;
 export interface ProvisionMembersInput {
+    configPath?: string;
     cfg: FleetConfig;
     cowork: CoworkAdapter;
     roomId: string;
@@ -12,6 +13,8 @@ export interface ProvisionMembersInput {
     brief?: string;
     goal?: string;
     startupWait?: Partial<StartupWaitPolicy>;
+    /** Append only the supplied new slots to an already active room. */
+    append?: boolean;
 }
 export interface StartupWaitPolicy {
     timeoutMs: number;

package/dist/rooms-tasks/provision.js

@@ -1,4 +1,5 @@
 import { readRoomReadiness } from '../agent-ours/service.js';
+import { ensureWorkspace, validateWorkspace } from './workspace.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
@@ -6,7 +7,8 @@ import { parse } from 'yaml';
 import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, activateRoom, getRoomRecord, } from './room-state.js';
 import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
 import { storedRoomLaunchPolicy } from './types.js';
-import { spawnTemp } from '../spawn.js';
+import { spawnTemp, resumeTaskSupervisor } from '../spawn.js';
+import { adoptLegacyTaskMember } from './legacy-task-member.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { selectionOrigin, summarizeResolvedLaunch, } from '../lifecycle-summary.js';
 import { canonicalJson } from '../canonical-json.js';
@@ -14,7 +16,7 @@ import { readLaunchSnapshot, redactLaunchDefinition } from './launch-snapshot.js
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from '../fleet-proxy.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
-import { closeManagedRoom, roomCloseLockPath } from './close.js';
+import { closeManagedRoom, roomCloseLockPath, CLOSE_LOCK_STALE_MS } from './close.js';
 import { withFileLock } from '../atomic-file.js';
 import { TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath } from './terminal.js';
 import { TaskStateError, taskDeletionState } from './task-state.js';
@@ -116,6 +118,7 @@ function settingsFor(member, cfg, sealed) {
 }
 function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid, anonymous) {
     return buildRoomMemberTask({
+        workspace: getRoomRecord(input.roomId)?.workspace?.path,
         taskId: input.taskId,
         roomId: input.roomId,
         roomIdentityCid,
@@ -129,7 +132,7 @@ function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCi
             cowork_role: member.coworkRole,
             persona: settings.persona,
         },
-        roster: members.map(candidate => ({
+        roster: [...(input.append ? (getRoomRecord(input.roomId)?.member_seats ?? []).filter(seat => !members.some(m => m.name === seat.role_name)).map(seat => ({ name: seat.role_name, coworkRole: seat.cowork_role })) : []), ...members].map(candidate => ({
             role_name: candidate.name,
             cowork_role: candidate.coworkRole,
         })),
@@ -142,6 +145,10 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
     try {
         const role = parse(readFileSync(`${dir}/role.yaml`, 'utf8'));
         const startup = role.roomMemberStartup;
+        const workspace = getRoomRecord(roomId)?.workspace;
+        if (workspace && (role.cwd !== workspace.path
+            || JSON.stringify(startup?.workspace) !== JSON.stringify(workspace)))
+            return false;
         return role.identity === member.name
             && startup?.room_id === roomId
             && startup.room_identity_cid === roomIdentityCid
@@ -201,6 +208,22 @@ async function retainRunningLaunch(input) {
                 } });
             return true;
         }
+        if (supervisor.taskOwner) {
+            await resumeTaskSupervisor(member.name, provision.binPath);
+            updateMemberStartup(provision.roomId, member.name, { launch: {
+                    ...retainedLaunch, state: 'launched', launch_id: supervisor.launchId,
+                    presentation: retainedLaunch.presentation ?? presentationFromStatePath(dir, settings, member.coworkRole),
+                    updated_at: new Date().toISOString(),
+                } });
+            return true;
+        }
+        if (provision.taskId) {
+            const adopted = await adoptLegacyTaskMember({ taskId: provision.taskId, roomId: provision.roomId,
+                roomIdentityCid, creationActionId: retainedLaunch.action_id }, member.name);
+            if (adopted !== 'running-legacy')
+                await resumeTaskSupervisor(member.name, provision.binPath);
+            return true;
+        }
         await secureStoppedTempArchive(member.name, supervisor.launchId);
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 ...retainedLaunch, state: 'stopped', launch_id: supervisor.launchId,
@@ -209,6 +232,8 @@ async function retainRunningLaunch(input) {
         return false;
     }
     if (seat.launch?.state === 'launched' && !existsSync(dir)) {
+        if (provision.taskId)
+            throw Error(`retained task member ${member.name} is missing; explicit reconciliation required`);
         if (!seat.launch.launch_id || !seat.launch.action_id)
             throw new Error(`missing durable launch identity for disappeared ${member.name}`);
         const archive = await secureStoppedTempArchive(member.name, seat.launch.launch_id);
@@ -234,35 +259,16 @@ async function retainRunningLaunch(input) {
     }
     return false;
 }
-/**
- * Member-launch publication window: for a task-bound room, the durable launch
- * intent, spawn, and launch record publish under the common task-operation
- * lock so an accepted deletion linearizes strictly before (bounded abort — no
- * spawn happens) or strictly after (the seat's launch record is visible to
- * deletion retirement). The lock is held per member only, never across
- * seat-wait loops.
- */
 async function launchMember(input) {
-    const taskId = input.provision.taskId;
-    const launch = () => withFileLock(roomCloseLockPath(input.provision.roomId), () => {
-        assertProvisioningOpen(input.provision);
-        return launchMemberUnlocked(input);
-    }, {}, TASK_OPERATION_LOCK_STALE_MS);
-    if (!taskId)
-        return launch();
-    return withFileLock(taskOperationLockPath(taskId), () => {
-        if (taskDeletionState(taskId) !== 'none')
-            throw new Error(`task ${taskId} is pending deletion; aborting member launch for ${input.member.name}`);
-        return launch();
-    }, {}, TASK_OPERATION_LOCK_STALE_MS);
-}
-async function launchMemberUnlocked(input) {
+    // provisionMembers holds the task and room lifecycle locks through every launch.
+    assertProvisioningOpen(input.provision);
     const { provision, member, settings, startup } = input;
     const seat = getRoomRecord(provision.roomId).member_seats
         .find(candidate => candidate.role_name === member.name);
     const actionId = randomUUID();
     let effectiveActionId = actionId;
     const attempt = (seat.launch?.attempt ?? 0) + 1;
+    const taskSupervised = Boolean(provision.taskId) && process.env.OURS_FLEET_SUPERVISOR !== 'none';
     const taskSha = sha256Text(startup.task);
     const effectiveAgentDefinition = structuredClone(settings.definition);
     const { projection: agentDefinition, fingerprint: agentFingerprint } = launchDefinition(effectiveAgentDefinition);
@@ -270,6 +276,7 @@ async function launchMemberUnlocked(input) {
         ? process.env[FLEET_PROXY_CALLER_ENV] : undefined;
     updateMemberStartup(provision.roomId, member.name, { launch: {
             state: 'intent', attempt, action_id: actionId, mission_sha256: taskSha,
+            ...(taskSupervised ? { task_supervised: true } : {}),
             agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
             agent_template: settings.template, agent_template_hash: settings.templateHash,
             ...(proxyCaller ? { caller_role: proxyCaller } : {}),
@@ -278,6 +285,7 @@ async function launchMemberUnlocked(input) {
     try {
         const launched = await spawnRoomMember({
             name: member.name,
+            configPath: provision.configPath,
             temp: true,
             identity: member.name,
             agentDefinition: settings.definition,
@@ -293,6 +301,7 @@ async function launchMemberUnlocked(input) {
         if (launched.creationActionId !== actionId) {
             updateMemberStartup(provision.roomId, member.name, { launch: {
                     state: 'intent', attempt, action_id: launched.creationActionId,
+                    ...(taskSupervised ? { task_supervised: true } : {}),
                     mission_sha256: taskSha, agent_definition: agentDefinition,
                     agent_fingerprint: agentFingerprint,
                     agent_template: settings.template, agent_template_hash: settings.templateHash,
@@ -310,6 +319,7 @@ async function launchMemberUnlocked(input) {
             : presentationFromStatePath(launchedDir, settings, member.coworkRole);
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'launched', attempt, action_id: launched.creationActionId, mission_sha256: taskSha,
+                ...(taskSupervised ? { task_supervised: true } : {}),
                 agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 agent_template: settings.template, agent_template_hash: settings.templateHash,
                 presentation,
@@ -320,6 +330,7 @@ async function launchMemberUnlocked(input) {
     catch (error) {
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'failed', attempt, action_id: effectiveActionId, mission_sha256: taskSha,
+                ...(taskSupervised ? { task_supervised: true } : {}),
                 agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 agent_template: settings.template, agent_template_hash: settings.templateHash,
                 ...(proxyCaller ? { caller_role: proxyCaller } : {}),
@@ -349,6 +360,8 @@ function reconcileMemberSeats(roomId, members, observed, ownerSeatCid) {
         && seat.seat_state === 'active');
     const seats = current.member_seats.map(seat => {
         const member = members.find(candidate => candidate.name === seat.role_name);
+        if (!member)
+            return seat;
         const readiness = readRoomReadiness(current.room_identity_cid, member.name);
         if (!readiness || readiness.room !== roomId || readiness.invite !== seat.invite_id) {
             complete = false;
@@ -383,9 +396,33 @@ function assertProvisioningOpen(input) {
         throw new Error(`room ${input.roomId} is ${room.state}; refusing to provision members`);
 }
 export async function provisionMembers(input) {
+    // Same lock order as terminal/deletion settlement. Serialize concurrent retries
+    // and standalone retirement as well as member publication. Seat waits are bounded.
+    const run = () => withFileLock(roomCloseLockPath(input.roomId), () => {
+        assertProvisioningOpen(input);
+        if (input.append) {
+            const task = input.taskId ? getTask(input.taskId) : undefined;
+            const room = getRoomRecord(input.roomId);
+            if (!task || !['active', 'review'].includes(task.state) || room?.state !== 'active'
+                || room.task_id !== task.task_id || room.room_identity_cid !== task.room_identity_cid)
+                throw new Error('Adding an agent requires the exact active task room');
+            const names = expandMembers(input.template, shortId(task.task_id)).map(m => m.name);
+            if (room.member_seats.some(seat => names.includes(seat.role_name)))
+                throw new Error('Member slot is already recorded; inspect its existing launch');
+            if (room.member_seats.some(seat => seat.seat_state !== 'active'))
+                throw new Error('Existing member admission must finish before adding an agent');
+        }
+        if (!getRoomRecord(input.roomId))
+            throw new Error(`room ${input.roomId} is missing; refusing provisioning`);
+        return provisionMembersUnlocked(input);
+    }, {}, CLOSE_LOCK_STALE_MS);
+    return input.taskId
+        ? withFileLock(taskOperationLockPath(input.taskId), run, {}, TASK_OPERATION_LOCK_STALE_MS)
+        : run();
+}
+async function provisionMembersUnlocked(input) {
     const { cfg, cowork, roomId, taskId, template } = input;
-    assertProvisioningOpen(input);
-    // Deletion-epoch pre-check; each member launch re-checks under the lock.
+    // The common task-operation lock protects this epoch through all member launches.
     if (taskId && taskDeletionState(taskId) !== 'none')
         throw new Error(`task ${taskId} is pending deletion; refusing to provision members`);
     const prefix = taskId ? shortId(taskId) : `room-${shortId(roomId)}`;
@@ -397,6 +434,12 @@ export async function provisionMembers(input) {
     const existing = getRoomRecord(roomId);
     if (!existing?.room_identity_cid)
         throw new Error(`room ${roomId} has no pinned room identity CID`);
+    if (existing.workspace) {
+        validateWorkspace(existing.workspace, taskId ? 'task' : 'room', taskId ?? roomId);
+        ensureWorkspace(existing.workspace);
+        for (const setting of settings.values())
+            setting.definition.cwd = existing.workspace.path;
+    }
     const roomIdentityCid = existing.room_identity_cid;
     const ownerSeatCid = existing.owner_seat_cid ?? null;
     const roomPolicy = storedRoomLaunchPolicy(existing.room_policy);
@@ -404,22 +447,23 @@ export async function provisionMembers(input) {
     const resuming = members.length > 0
         && members.every(member => persistedNames.has(member.name));
     if (!resuming) {
-        advanceSaga(roomId, 'create_members', 3);
-        updateMemberSeats(roomId, members.map(member => {
-            const memberSettings = settings.get(member.name);
-            const evidence = launchDefinition(memberSettings.definition);
-            return ({
-                role_name: member.name,
-                slot: member.slot,
-                cowork_role: member.coworkRole,
-                seat_state: 'pending',
-                launch: { state: 'pending', attempt: 0,
-                    agent_definition: evidence.projection, agent_fingerprint: evidence.fingerprint,
-                    agent_template: memberSettings.template,
-                    agent_template_hash: memberSettings.templateHash,
-                    updated_at: new Date().toISOString() },
-            });
-        }));
+        if (!input.append)
+            advanceSaga(roomId, 'create_members', 3);
+        updateMemberSeats(roomId, [...(input.append ? existing.member_seats : []), ...members.map(member => {
+                const memberSettings = settings.get(member.name);
+                const evidence = launchDefinition(memberSettings.definition);
+                return ({
+                    role_name: member.name,
+                    slot: member.slot,
+                    cowork_role: member.coworkRole,
+                    seat_state: 'pending',
+                    launch: { state: 'pending', attempt: 0,
+                        agent_definition: evidence.projection, agent_fingerprint: evidence.fingerprint,
+                        agent_template: memberSettings.template,
+                        agent_template_hash: memberSettings.templateHash,
+                        updated_at: new Date().toISOString() },
+                });
+            })], input.append ? template : undefined);
     }
     else {
         for (const member of members) {
@@ -437,7 +481,8 @@ export async function provisionMembers(input) {
         now: input.startupWait?.now ?? Date.now,
         sleep: input.startupWait?.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms))),
     };
-    advanceSaga(roomId, 'join_role_groups', 4);
+    if (!input.append)
+        advanceSaga(roomId, 'join_role_groups', 4);
     try {
         const initialRoom = await cowork.recoverRoom(roomId);
         assertCoworkRoomPolicy(initialRoom, roomPolicy.anonymous);
@@ -482,6 +527,8 @@ export async function provisionMembers(input) {
                     member,
                     settings: settings.get(member.name),
                     startup: {
+                        ...(taskId ? { task_id: taskId } : {}),
+                        workspace: existing.workspace,
                         room_id: roomId,
                         room_identity_cid: roomIdentityCid,
                         identity_name: member.name,
@@ -521,7 +568,8 @@ export async function provisionMembers(input) {
         }
         throw error;
     }
-    advanceSaga(roomId, 'wait_seats', 5);
+    if (!input.append)
+        advanceSaga(roomId, 'wait_seats', 5);
     const deadline = policy.now() + policy.timeoutMs;
     let delay = policy.initialDelayMs;
     for (;;) {
@@ -531,10 +579,12 @@ export async function provisionMembers(input) {
         if (reconciled.complete && remote.state === 'active')
             break;
         if (policy.now() >= deadline) {
-            advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
+            if (!input.append)
+                advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
             return getRoomRecord(roomId);
         }
-        advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
+        if (!input.append)
+            advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
         await policy.sleep(delay);
         delay = Math.min(policy.maxDelayMs, Math.max(delay + 1, delay * 2));
     }
@@ -559,9 +609,11 @@ export async function provisionMembers(input) {
             };
         });
         updateTaskMembers(taskId, taskMembers);
-        if (getTask(taskId).blocked)
+        if (!input.append && getTask(taskId).blocked)
             unblockTask(taskId);
     }
+    if (input.append)
+        return getRoomRecord(roomId);
     advanceSaga(roomId, 'activate', 6);
     const record = activateRoom(roomId);
     if (taskId)
@@ -592,7 +644,7 @@ export async function reconcileExistingTaskMembers(input) {
                 || remote.state !== 'active')
                 throw new Error('Cowork room is not the exact active room');
             assertCoworkRoomPolicy(remote, storedRoomLaunchPolicy(current.room_policy).anonymous);
-            if (current.owner_seat_cid && !remote.seats.some(seat => seat.identity_cid === current.owner_seat_cid && seat.seat_state === 'active'))
+            if (current.owner_seat_cid && !remote.seats.some(seat => seat.identity_cid.toLowerCase() === current.owner_seat_cid.toLowerCase() && seat.seat_state === 'active'))
                 throw new Error('expected Owner seat is not active');
             const seats = [];
             for (const seat of current.member_seats) {

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

@@ -0,0 +1,19 @@
+import { tempSupervisorLiveness } from '../temp-lifecycle.js';
+import { resumeTaskSupervisor } from '../spawn.js';
+import type { CoworkAdapter } from './cowork-adapter.js';
+export type MemberRecovery = {
+    name: string;
+    status: 'running' | 'resumed' | 'migration_pending' | 'recovery_reset';
+};
+export interface TaskMemberRecoveryDeps {
+    liveness?: typeof tempSupervisorLiveness;
+    resume?: typeof resumeTaskSupervisor;
+    adopt?(taskId: string, roomId: string, name: string): Promise<void>;
+}
+/** Explicit supported recovery; never creates an identity, seat, invite, or session ID. */
+export declare function recoverTaskMembers(input: {
+    taskId: string;
+    binPath: string;
+    cowork?: Pick<CoworkAdapter, 'getRoom'>;
+    deps?: TaskMemberRecoveryDeps;
+}): Promise<MemberRecovery[]>;