@ours.network/fleet 1.2.0-nightly.1 → 1.2.0-nightly.11

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

@@ -0,0 +1,75 @@
+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 expected = room.template_snapshot?.members.reduce((n, member) => n + member.count, 0);
+    if (expected === undefined || room.member_seats.length !== expected
+        || new Set(room.member_seats.map(seat => seat.role_name)).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.some(seat => seat.identity_cid === room.owner_seat_cid && seat.seat_state === 'active'))
+        return degraded('owner_seat_missing');
+    for (const seat of room.member_seats) {
+        const member = seat.role_name;
+        if (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' }, 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);
+        }
+        catch {
+            return unknown('control_unavailable', member);
+        }
+    }
+}

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

@@ -21,6 +21,17 @@ export interface StartupWaitPolicy {
     sleep(ms: number): Promise<void>;
 }
 export declare function provisionMembers(input: ProvisionMembersInput): Promise<RoomOrchestrationRecord>;
+/** Reconcile proven, admitted launches without any spawn, archive, invite or recovery path. */
+export declare function reconcileExistingTaskMembers(input: {
+    taskId: string;
+    checkOnly?: boolean;
+    cowork: Pick<CoworkAdapter, 'getRoom'>;
+    expectedLaunches: ReadonlyArray<{
+        role_name: string;
+        launch_id: string;
+        identity_cid: string;
+    }>;
+}): Promise<RoomOrchestrationRecord>;
 export declare function cleanupMembers(input: {
     roomId: string;
     taskId?: string;

package/dist/rooms-tasks/provision.js

@@ -1,3 +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';
@@ -13,7 +15,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 } 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';
@@ -115,6 +117,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,
@@ -141,6 +144,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
@@ -149,8 +156,7 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
             && (startup.anonymous ?? false) === anonymous
             && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
-            && typeof startup.invite === 'string'
-            && startup.invite.length > 0;
+            && startup.invite === '';
     }
     catch {
         return false;
@@ -234,25 +240,9 @@ 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;
-    if (!taskId)
-        return launchMemberUnlocked(input);
-    return withFileLock(taskOperationLockPath(taskId), () => {
-        if (taskDeletionState(taskId) !== 'none')
-            throw new Error(`task ${taskId} is pending deletion; aborting member launch for ${input.member.name}`);
-        return launchMemberUnlocked(input);
-    }, {}, 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);
@@ -345,7 +335,14 @@ 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);
+        const readiness = readRoomReadiness(current.room_identity_cid, member.name);
+        if (!readiness || readiness.room !== roomId || readiness.invite !== seat.invite_id) {
+            complete = false;
+            return seat;
+        }
         const found = exactCoworkSeat(observed, member, seat.invite_id);
+        if (found && found.identity_cid !== readiness.cid)
+            throw new Error('Cowork seat CID does not match supervisor provisioned identity');
         if (!found || found.seat_state !== 'active') {
             complete = false;
             return seat;
@@ -364,9 +361,29 @@ function assertCoworkRoomPolicy(room, expectedAnonymous) {
     if ((room.anonymous ?? false) !== expectedAnonymous)
         throw new Error(`Cowork anonymity (${String(room.anonymous ?? false)}) does not match Fleet's durable Room policy (${String(expectedAnonymous)})`);
 }
+function assertProvisioningOpen(input) {
+    if (input.taskId && getTask(input.taskId).terminal_intent)
+        throw new Error(`task ${input.taskId} has an accepted terminal intent; refusing to provision members`);
+    const room = getRoomRecord(input.roomId);
+    if (room?.state === 'closing' || room?.state === 'closed')
+        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 (!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;
-    // 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)}`;
@@ -378,6 +395,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);
@@ -439,17 +462,31 @@ export async function provisionMembers(input) {
                 provision: input, member, settings: settings.get(member.name), task, roomIdentityCid,
             }))
                 continue;
+            // A previous failed launch keeps its invite pointer durably. Never
+            // overwrite that requirement until the supported revoke has succeeded;
+            // a transport failure must fence subsequent invite issuance too.
+            if (currentSeat.invite_id) {
+                const observed = await cowork.getRoom(roomId);
+                if (!observed || observed.identity_cid !== roomIdentityCid)
+                    throw new Error('cannot verify room before failed-attempt invite cleanup');
+                if (observed.seats.some(seat => seat.invite_id === currentSeat.invite_id
+                    && seat.seat_state !== 'removed'))
+                    throw new Error('failed-attempt invite has an admitted seat; reconcile before replacing the member');
+                await cowork.revokeInvite(roomId, currentSeat.invite_id);
+            }
             const issued = await cowork.issueInvite(roomId, {
                 mode: 'one_time', role: member.coworkRole, min_accepts: 1,
             });
-            const seats = getRoomRecord(roomId).member_seats.map(seat => seat.role_name === member.name ? { ...seat, invite_id: issued.invite_id } : seat);
-            updateMemberSeats(roomId, seats);
             try {
+                assertProvisioningOpen(input);
+                const seats = getRoomRecord(roomId).member_seats.map(seat => seat.role_name === member.name ? { ...seat, invite_id: issued.invite_id } : seat);
+                updateMemberSeats(roomId, seats);
                 await launchMember({
                     provision: input,
                     member,
                     settings: settings.get(member.name),
                     startup: {
+                        workspace: existing.workspace,
                         room_id: roomId,
                         room_identity_cid: roomIdentityCid,
                         identity_name: member.name,
@@ -463,7 +500,12 @@ export async function provisionMembers(input) {
                 });
             }
             catch (error) {
-                await cowork.revokeInvite(roomId, issued.invite_id).catch(() => { });
+                try {
+                    await cowork.revokeInvite(roomId, issued.invite_id);
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], 'member launch failed and invite cleanup is unresolved; retry must revoke the retained requirement first');
+                }
                 throw error;
             }
         }
@@ -491,7 +533,7 @@ export async function provisionMembers(input) {
         const remote = await cowork.recoverRoom(roomId);
         assertCoworkRoomPolicy(remote, roomPolicy.anonymous);
         const reconciled = reconcileMemberSeats(roomId, members, remote.seats, ownerSeatCid ?? undefined);
-        if (reconciled.complete)
+        if (reconciled.complete && remote.state === 'active')
             break;
         if (policy.now() >= deadline) {
             advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
@@ -531,6 +573,76 @@ export async function provisionMembers(input) {
         activateTask(taskId);
     return record;
 }
+/** Reconcile proven, admitted launches without any spawn, archive, invite or recovery path. */
+export async function reconcileExistingTaskMembers(input) {
+    return withFileLock(taskOperationLockPath(input.taskId), async () => {
+        const task = getTask(input.taskId);
+        if (!['provisioning', 'active'].includes(task.state) || task.terminal_intent || taskDeletionState(input.taskId) !== 'none'
+            || !task.room_id)
+            throw new Error('task is not open for existing-member reconciliation');
+        const roomId = task.room_id;
+        return withFileLock(roomCloseLockPath(roomId), async () => {
+            const current = getRoomRecord(roomId);
+            if (!current || !['provisioning', 'active'].includes(current.state) || current.close
+                || current.task_id !== input.taskId || !current.room_identity_cid
+                || task.room_identity_cid !== current.room_identity_cid)
+                throw new Error('room is not open for existing-member reconciliation');
+            const names = new Set(input.expectedLaunches.map(seat => seat.role_name));
+            if (!names.size || names.size !== input.expectedLaunches.length
+                || current.member_seats.length !== names.size
+                || current.member_seats.some(seat => !names.has(seat.role_name)))
+                throw new Error('expected launch roster does not match the persisted room');
+            const remote = await input.cowork.getRoom(roomId);
+            if (!remote || remote.room_id !== roomId || remote.identity_cid !== current.room_identity_cid
+                || 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'))
+                throw new Error('expected Owner seat is not active');
+            const seats = [];
+            for (const seat of current.member_seats) {
+                const expected = input.expectedLaunches.find(item => item.role_name === seat.role_name);
+                const launch = seat.launch;
+                if (seat.seat_state === 'removed' || !seat.invite_id || launch?.state !== 'launched'
+                    || launch.launch_id !== expected.launch_id || !launch.action_id || !launch.mission_sha256
+                    || (seat.identity_cid && seat.identity_cid !== expected.identity_cid))
+                    throw new Error('persisted member launch does not match reconciliation evidence');
+                const dir = agentDir(seat.role_name, true);
+                if (!launchMatches(dir, { name: seat.role_name, coworkRole: seat.cowork_role }, launch.action_id, launch.mission_sha256, roomId, current.room_identity_cid, seat.invite_id, storedRoomLaunchPolicy(current.room_policy).anonymous))
+                    throw new Error('member startup provenance mismatch');
+                const supervisor = readTempSupervisor(dir);
+                if (!supervisor || supervisor.role !== seat.role_name || supervisor.launchId !== expected.launch_id
+                    || await tempSupervisorLiveness(dir) !== 'running')
+                    throw new Error('expected member supervisor is not running');
+                const ready = readRoomReadiness(current.room_identity_cid, seat.role_name);
+                const matches = remote.seats.filter(item => item.display_name === seat.role_name
+                    && item.seat_state !== 'removed');
+                const found = matches[0];
+                if (!ready || ready.room !== roomId || ready.invite !== seat.invite_id
+                    || ready.cid !== expected.identity_cid || matches.length !== 1 || !found
+                    || found.identity_cid !== expected.identity_cid || found.role !== seat.cowork_role
+                    || found.seat_state !== 'active' || found.invite_id !== seat.invite_id)
+                    throw new Error('member readiness or authenticated Cowork seat mismatch');
+                seats.push({ ...seat, identity_cid: expected.identity_cid, seat_state: 'active' });
+            }
+            if (input.checkOnly)
+                return current;
+            // No mutation until the complete roster has passed; these writes are replayable
+            // under the same task/room lifecycle locks if interrupted between files.
+            updateMemberSeats(roomId, seats);
+            updateTaskMembers(input.taskId, seats.map(seat => ({ name: seat.role_name,
+                identity_cid: seat.identity_cid, slot: seat.slot, cowork_role: seat.cowork_role })));
+            if (getTask(input.taskId).blocked)
+                unblockTask(input.taskId);
+            if (current.state !== 'active')
+                advanceSaga(roomId, 'activate', 6);
+            const activated = current.state === 'active' ? getRoomRecord(roomId) : activateRoom(roomId);
+            if (task.state !== 'active')
+                activateTask(input.taskId);
+            return activated;
+        }, {}, TASK_OPERATION_LOCK_STALE_MS);
+    }, {}, TASK_OPERATION_LOCK_STALE_MS);
+}
 export async function cleanupMembers(input) {
     const room = getRoomRecord(input.roomId);
     if (!room)

package/dist/rooms-tasks/room-state.js

@@ -2,6 +2,8 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:f
 import { join } from 'node:path';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
+import { planWorkspace, ensureWorkspace } from './workspace.js';
+import { getTask } from './task-state.js';
 import { storedRoomLaunchPolicy } from './types.js';
 import { releaseLaunchSnapshot } from './launch-snapshot.js';
 export const roomsDir = () => join(stateRoot(), 'rooms');
@@ -25,6 +27,8 @@ export function createRoomRecord(input) {
         const requested = storedRoomLaunchPolicy(input.room_policy);
         if (JSON.stringify(before) !== JSON.stringify(requested))
             throw new RoomStateError(`room ${input.room_id} launch policy mismatch`);
+        if (existing.workspace)
+            ensureWorkspace(existing.workspace);
         return existing;
     }
     const record = {
@@ -40,7 +44,10 @@ export function createRoomRecord(input) {
         state: 'provisioning',
         created_at: new Date().toISOString(),
     };
+    record.workspace = input.task_id ? getTask(input.task_id).workspace : planWorkspace('room', input.room_id);
     writeRoom(record);
+    if (record.workspace)
+        ensureWorkspace(record.workspace);
     return record;
 }
 export function getRoomRecord(id) {
@@ -112,6 +119,8 @@ export function setOwnerSeat(id, ownerSeatCid, inviteFingerprint) {
 }
 export function updateMemberSeats(id, seats) {
     const r = readRoom(id);
+    if (r.state === 'closing' || r.state === 'closed')
+        throw new RoomStateError(`room ${id} is ${r.state}; member provisioning is fenced`);
     r.member_seats = seats;
     writeRoom(r);
     return r;
@@ -135,6 +144,8 @@ const LAUNCH_ORDER = [
 ];
 export function updateMemberStartup(id, roleName, update) {
     const r = readRoom(id);
+    if (r.state === 'closing' || r.state === 'closed')
+        throw new RoomStateError(`room ${id} is ${r.state}; member provisioning is fenced`);
     const seat = r.member_seats.find(candidate => candidate.role_name === roleName);
     if (!seat)
         throw new RoomStateError(`room ${id} has no recorded member ${roleName}`);
@@ -151,6 +162,8 @@ export function updateMemberStartup(id, roleName, update) {
 }
 export function activateRoom(id) {
     const r = readRoom(id);
+    if (r.state === 'closing' || r.state === 'closed')
+        throw new RoomStateError(`room ${id} is ${r.state}; activation is fenced`);
     r.state = 'active';
     r.saga = { phase: 'completed', step_index: 0 };
     delete r.provisioning_detail;

package/dist/rooms-tasks/task-state.d.ts

@@ -1,3 +1,4 @@
+import type { ArchivedMemberAbsence } from './types.js';
 import type { TaskRecord, TaskState, TaskOrigin, TaskTemplateRef, TaskOutcome, TaskMemberRole, TaskTerminalIntent, TaskDeletionActor, TaskDeletionMemberPhase } from './types.js';
 export declare const tasksDir: () => string;
 export declare class TaskStateError extends Error {
@@ -74,6 +75,7 @@ export interface TaskDeletionReceipt {
     original_state: TaskState;
     room_id?: string;
     member_count: number;
+    archived_absences?: ArchivedMemberAbsence[];
     settled_at?: string;
     result?: 'deleted';
 }
@@ -122,6 +124,10 @@ export declare function advanceTaskDeletionMember(id: string, name: string, phas
 interface SeatEvidence {
     role_name: string;
     identity_cid?: string;
+    launch?: {
+        launch_id?: string;
+        action_id?: string;
+    };
     retirement?: {
         phase: TaskDeletionMemberPhase;
         launch_id: string;
@@ -146,10 +152,14 @@ export declare function upsertTaskDeletionMembersFromSeats(id: string, seats: Re
  *
  * The room saga is trusted for phase jumps, but partial or corrupt retained
  * records must not become false success: every seat must be identity_absent;
- * a real launch requires archive evidence; an identity-less seat is accepted
- * only via the never-launched proof.
+ * a real launch requires archive evidence; an identity-less seat requires
+ * never-launched proof or a freshly verified archived-absence checkpoint.
+ */
+export declare function importTaskDeletionRetirementEvidence(id: string, seats: ReadonlyArray<SeatEvidence>, proofs?: ReadonlyArray<ArchivedMemberAbsence>): TaskRecord;
+/** Settlement-only checkpoint, under the task-operation lock after fresh archive verification.
+ * From here retries still verify live absence, but owned archives may be consumed.
  */
-export declare function importTaskDeletionRetirementEvidence(id: string, seats: ReadonlyArray<SeatEvidence>): TaskRecord;
+export declare function beginTaskWorkspaceCleanup(id: string): void;
 /**
  * Physically remove a deletion-pending task record. Settlement-only: callers
  * must have completed member retirement and room cleanup first. Missing

package/dist/rooms-tasks/task-state.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
+import { planWorkspace, ensureWorkspace } from './workspace.js';
 import { storedRoomLaunchPolicy, TASK_TERMINAL_STATES, TASK_CANCELLABLE_STATES } from './types.js';
 import { DEFAULT_TASK_LIST_ID, readTaskLists } from './task-lists.js';
 export const tasksDir = () => join(stateRoot(), 'tasks');
@@ -127,7 +128,7 @@ export function assertNoPendingDeletion(task) {
 }
 export function createTask(input) {
     const key = input.idempotency_key ?? randomUUID();
-    const existing = findByIdempotencyKey(key);
+    const existing = listTasks({ includeDeleting: true }).find(task => task.idempotency_key === key);
     if (existing) {
         const existingPlan = existing.execution_plan?.plan_hash;
         const requestedPlan = input.execution_plan?.plan_hash;
@@ -135,7 +136,13 @@ export function createTask(input) {
         const requestedPolicy = storedRoomLaunchPolicy(input.execution_plan?.room_policy);
         if (existingPlan !== requestedPlan || JSON.stringify(existingPolicy) !== JSON.stringify(requestedPolicy))
             throw new TaskStateError(`idempotency key '${key}' was already used with a different execution plan`);
-        return existing;
+        return withTaskLock(existing.task_id, () => {
+            const fresh = readTask(existing.task_id);
+            assertNoPendingDeletion(fresh);
+            if (fresh.workspace)
+                ensureWorkspace(fresh.workspace);
+            return fresh;
+        });
     }
     const state = input.start === false ? 'backlog' : 'provisioning';
     const record = {
@@ -155,7 +162,9 @@ export function createTask(input) {
         created_at: new Date().toISOString(),
         started_at: state === 'provisioning' ? new Date().toISOString() : undefined,
     };
+    record.workspace = planWorkspace('task', record.task_id);
     writeTask(record);
+    ensureWorkspace(record.workspace);
     return readTask(record.task_id);
 }
 export function getTask(id) { return withTaskLock(id, () => readTask(id)); }
@@ -505,7 +514,8 @@ function writeDeletionReceiptForIntent(stored) {
         actor: deletion.actor,
         original_state: stored.state,
         room_id: deletion.room_id,
-        member_count: deletion.members.length,
+        member_count: deletion.members.length + (deletion.archived_absences?.length ?? 0),
+        ...(deletion.archived_absences?.length ? { archived_absences: deletion.archived_absences } : {}),
     };
     replaceFileAtomically(deletionReceiptPath(stored.task_id), JSON.stringify(receipt, null, 2) + '\n');
 }
@@ -688,10 +698,10 @@ export function upsertTaskDeletionMembersFromSeats(id, seats) {
  *
  * The room saga is trusted for phase jumps, but partial or corrupt retained
  * records must not become false success: every seat must be identity_absent;
- * a real launch requires archive evidence; an identity-less seat is accepted
- * only via the never-launched proof.
+ * a real launch requires archive evidence; an identity-less seat requires
+ * never-launched proof or a freshly verified archived-absence checkpoint.
  */
-export function importTaskDeletionRetirementEvidence(id, seats) {
+export function importTaskDeletionRetirementEvidence(id, seats, proofs = []) {
     return withTaskLock(id, () => {
         assertCanonicalTaskId(id);
         const stored = JSON.parse(readFileSync(taskPath(id), 'utf8'));
@@ -708,6 +718,18 @@ export function importTaskDeletionRetirementEvidence(id, seats) {
             if (!seat.identity_cid) {
                 if (neverLaunched)
                     continue; // provably never held a managed identity
+                const proof = proofs.find(value => value.name === seat.role_name);
+                if (proof && proof.launch_id === evidence.launch_id && proof.archive_path === evidence.archive_path
+                    && proof.launch_id === seat.launch?.launch_id && proof.action_id === seat.launch?.action_id) {
+                    const existing = stored.deletion.archived_absences?.find(value => value.name === proof.name);
+                    if (existing && (existing.launch_id !== proof.launch_id || existing.action_id !== proof.action_id
+                        || existing.archive_path !== proof.archive_path))
+                        throw new TaskStateError('Archived absence checkpoint ownership is immutable');
+                    stored.deletion.archived_absences ??= [];
+                    if (!existing)
+                        stored.deletion.archived_absences.push({ ...proof });
+                    continue;
+                }
                 throw new TaskStateError(`task ${id} deletion member '${seat.role_name}' has retirement evidence but no identity CID`);
             }
             let cursor = findCursorForSeat(id, stored, seat);
@@ -729,9 +751,23 @@ export function importTaskDeletionRetirementEvidence(id, seats) {
             cursor.updated_at = now;
         }
         writeTask(stored);
+        writeDeletionReceiptForIntent(stored);
         return presentTaskLenient(stored);
     });
 }
+/** Settlement-only checkpoint, under the task-operation lock after fresh archive verification.
+ * From here retries still verify live absence, but owned archives may be consumed.
+ */
+export function beginTaskWorkspaceCleanup(id) {
+    withTaskLock(id, () => {
+        const stored = JSON.parse(readFileSync(taskPath(id), 'utf8'));
+        if (stored.deletion?.status !== 'pending' || !stored.workspace
+            || stored.deletion.members.some(member => member.phase !== 'identity_absent'))
+            throw new TaskStateError('Task is not ready for workspace cleanup');
+        stored.deletion.workspace_cleanup_started_at ??= new Date().toISOString();
+        writeTask(stored);
+    });
+}
 /**
  * Physically remove a deletion-pending task record. Settlement-only: callers
  * must have completed member retirement and room cleanup first. Missing

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

@@ -73,6 +73,13 @@ export interface TaskDeletionMemberCursor {
  * evidence. While pending, the task is hidden from normal operation and every
  * lifecycle mutation or room publication is rejected.
  */
+export interface ArchivedMemberAbsence {
+    name: string;
+    launch_id: string;
+    action_id: string;
+    archive_path: string;
+    checked_at: string;
+}
 export interface TaskDeletionIntent {
     status: 'pending';
     accepted_at: string;
@@ -80,6 +87,9 @@ export interface TaskDeletionIntent {
     room_id?: string;
     /** Snapshot of managed members at acceptance; the missing-room retirement evidence. */
     members: TaskDeletionMemberCursor[];
+    archived_absences?: ArchivedMemberAbsence[];
+    /** Archive proofs were verified before owned workspace cleanup may consume them. */
+    workspace_cleanup_started_at?: string;
     error?: string;
     error_at?: string;
     recovery_hint?: string;
@@ -87,6 +97,7 @@ export interface TaskDeletionIntent {
     first_recovery_hint?: string;
 }
 export interface TaskRecord {
+    workspace?: import('./workspace.js').OwnedWorkspace;
     task_id: string;
     /** Stable organizational list identifier. Missing legacy values mean `default`. */
     list_id: string;
@@ -227,6 +238,7 @@ export interface RoomMemberSeat {
     retirement?: MemberRetirement;
 }
 export interface RoomOrchestrationRecord {
+    workspace?: import('./workspace.js').OwnedWorkspace;
     room_id: string;
     room_identity_cid?: string;
     room_name: string;

package/dist/rooms-tasks/workspace-artifacts.d.ts

@@ -0,0 +1,6 @@
+import { type OwnedWorkspace } from './workspace.js';
+/** Runtime control state stays in Fleet's live roster and recovery store. Its
+ * durable launch descriptor, not a name prefix or caller-supplied path, proves
+ * artifact ownership. Audit receipts/journals intentionally outlive deletion.
+ */
+export declare function collectWorkspaceArchives(workspace: OwnedWorkspace): void;