@ours.network/fleet 1.2.0-nightly.7 → 1.2.0-nightly.70

package/dist/rooms-tasks/cowork-adapter.js

@@ -1,22 +1,24 @@
 /**
- * Typed client for the ours-cowork v1 private management-socket protocol.
+ * Typed client for the ours-cowork v1 gateway management protocol.
  *
  * Cowork owns room state. Fleet only invokes the versioned JSON RPC exposed
- * by Cowork's Unix socket and projects the response into orchestration data.
+ * through the shared HTTP gateway and projects the response into orchestration data.
  */
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { createConnection } from 'node:net';
 import { readClientProfile } from '../client-profile.js';
 import { coworkHttpCall } from './cowork-http.js';
-const RPC_VERSION = 1;
 const DEFAULT_TIMEOUT_MS = 30_000;
-const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 export class CoworkUnavailableError extends Error {
-    constructor(message = 'Cowork management socket is not reachable', options) {
+    /**
+     * True only when the failure is a dependency that may still be starting
+     * (connection refused/reset, timeout, a gateway 502/503/504 without an RPC
+     * body). Selection, capability, credential and permission failures are
+     * never retryable, whatever transport reported them.
+     */
+    retryable;
+    constructor(message = 'Cowork gateway management is not reachable', options) {
         super(message, options);
         this.name = 'CoworkUnavailableError';
+        this.retryable = options?.retryable === true;
     }
 }
 export class CoworkProtocolError extends Error {
@@ -171,121 +173,13 @@ function projectHistoryRecord(value) {
     }
     return undefined;
 }
-/** Resolve the same config/state inputs as ours-cowork and return its Unix socket. */
-export function resolveCoworkSocketPath(options = {}) {
-    if (options.socketPath)
-        return resolve(options.socketPath);
-    const env = options.env ?? process.env;
-    const home = options.home ?? homedir();
-    const configuredPath = options.configPath ?? env.OURS_COWORK_CONFIG;
-    const configPath = resolve(configuredPath ?? join(home, '.ours-cowork', 'config.json'));
-    let stateDir = resolve(home, '.ours-cowork');
-    if (existsSync(configPath)) {
-        let parsed;
-        try {
-            parsed = JSON.parse(readFileSync(configPath, 'utf8'));
-        }
-        catch (error) {
-            throw new CoworkProtocolError('config', `malformed config at ${configPath}`, 'invalid_config', { cause: error });
-        }
-        const config = object(parsed, 'config', 'config');
-        if (config.version !== 1 || typeof config.stateDir !== 'string' || !config.stateDir)
-            throw new CoworkProtocolError('config', `invalid Cowork v1 config at ${configPath}`, 'invalid_config');
-        stateDir = resolve(config.stateDir);
-    }
-    else if (configuredPath !== undefined) {
-        throw new CoworkProtocolError('config', `configured Cowork config does not exist: ${configPath}`, 'invalid_config');
-    }
-    if (env.OURS_COWORK_STATE_DIR)
-        stateDir = resolve(env.OURS_COWORK_STATE_DIR);
-    return join(stateDir, 'management.sock');
-}
-function rpcCall(socketPath, method, params, timeoutMs, connect) {
-    const id = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    const request = `${JSON.stringify({ version: RPC_VERSION, id, method, params })}\n`;
-    return new Promise((resolveCall, rejectCall) => {
-        const socket = connect(socketPath);
-        let bytes = '';
-        let size = 0;
-        let settled = false;
-        let connected = false;
-        const finishError = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            socket.destroy();
-            rejectCall(error);
-        };
-        const timer = setTimeout(() => finishError(new CoworkUnavailableError(connected ? 'Cowork did not answer the management socket' : 'Cowork management socket is not reachable')), timeoutMs);
-        socket.setEncoding('utf8');
-        socket.once('connect', () => {
-            connected = true;
-            socket.write(request);
-        });
-        socket.on('data', (chunk) => {
-            if (settled)
-                return;
-            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-            size += Buffer.byteLength(text);
-            if (size > MAX_RESPONSE_BYTES) {
-                finishError(new CoworkProtocolError(method, 'response exceeded 4 MiB'));
-                return;
-            }
-            bytes += text;
-            const newline = bytes.indexOf('\n');
-            if (newline < 0)
-                return;
-            if (bytes.slice(newline + 1).trim() !== '') {
-                finishError(new CoworkProtocolError(method, 'daemon returned more than one response'));
-                return;
-            }
-            let response;
-            try {
-                response = object(JSON.parse(bytes.slice(0, newline)), method, 'RPC response');
-            }
-            catch (error) {
-                finishError(error instanceof CoworkProtocolError
-                    ? error : new CoworkProtocolError(method, 'daemon returned malformed JSON', 'protocol_error', { cause: error }));
-                return;
-            }
-            if (response.version !== RPC_VERSION || response.id !== id
-                || (Object.hasOwn(response, 'error') === Object.hasOwn(response, 'result'))) {
-                finishError(new CoworkProtocolError(method, 'daemon returned an invalid RPC response'));
-                return;
-            }
-            settled = true;
-            clearTimeout(timer);
-            socket.destroy();
-            if (Object.hasOwn(response, 'error')) {
-                const error = object(response.error, method, 'RPC error');
-                rejectCall(new CoworkProtocolError(method, typeof error.message === 'string' ? error.message : 'unknown RPC error', typeof error.code === 'string' ? error.code : 'rpc_error'));
-            }
-            else {
-                resolveCall(response.result);
-            }
-        });
-        socket.once('end', () => {
-            if (!settled)
-                finishError(new CoworkProtocolError(method, 'daemon closed without a complete response'));
-        });
-        socket.once('error', (error) => {
-            if (!settled)
-                finishError(new CoworkUnavailableError(error.code === 'EACCES' || error.code === 'EPERM'
-                    ? 'Cowork management socket access denied' : 'Cowork management socket is not reachable', { cause: error }));
-        });
-    });
-}
 export function createCoworkAdapter(options = {}) {
     const env = options.env ?? process.env;
-    const explicitLocal = options.socketPath !== undefined || options.configPath !== undefined
-        || env.OURS_COWORK_CONFIG !== undefined || !!env.OURS_COWORK_STATE_DIR;
-    const profile = explicitLocal ? undefined : readClientProfile({ ...env, HOME: options.home ?? env.HOME });
-    const remote = profile?.serverUrl ? profile : undefined;
-    const socketPath = remote ? undefined : resolveCoworkSocketPath(options);
+    if (options.socketPath !== undefined || options.configPath !== undefined)
+        throw new CoworkProtocolError('config', 'Local Cowork selectors are unsupported; configure the shared gateway client profile', 'invalid_config');
+    const profile = readClientProfile({ ...env, HOME: options.home ?? env.HOME });
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const connect = options.connect ?? ((path) => createConnection(path));
-    const call = (method, params) => remote ? coworkHttpCall(remote, method, params, timeoutMs) : rpcCall(socketPath, method, params, timeoutMs, connect);
+    const call = (method, params) => coworkHttpCall(profile, method, params, timeoutMs);
     return {
         async available() {
             try {

package/dist/rooms-tasks/cowork-http.js

@@ -2,6 +2,39 @@ import { randomUUID } from 'node:crypto';
 import { attachOursClient } from '@ours.network/sdk/client';
 import { readPrivateFile } from '@ours.network/sdk/connector';
 import { CoworkProtocolError, CoworkUnavailableError } from './cowork-adapter.js';
+const TRANSPORT_CODES = new Set(['EACCES', 'ENOENT', 'ECONNREFUSED', 'ECONNRESET',
+    'ETIMEDOUT', 'ENOTFOUND', 'EAI_AGAIN', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET',
+    'CERT_HAS_EXPIRED', 'ERR_TLS_CERT_ALTNAME_INVALID']);
+/** Failure kinds a dependency still starting (or restarting) produces. */
+const RETRYABLE_KINDS = new Set(['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN',
+    'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET', 'timeout']);
+/** Statuses a reverse proxy answers with while its upstream is not serving. */
+const GATEWAY_UNAVAILABLE = new Set([502, 503, 504]);
+/** Media type only, never parameters; anything unusual collapses to a fixed label. */
+function safeContentType(response) {
+    const value = (response.headers.get('content-type') ?? '').split(';')[0].trim().toLowerCase();
+    return /^[a-z0-9.+-]{1,40}\/[a-z0-9.+-]{1,40}$/.test(value) ? value : 'unknown type';
+}
+function safeFailureKind(error, signal) {
+    if (signal.aborted)
+        return 'timeout';
+    for (const value of [error, error instanceof Error ? error.cause : undefined]) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const code = value.code;
+        if (typeof code === 'string' && TRANSPORT_CODES.has(code))
+            return code;
+        const name = value.name;
+        if (name === 'TimeoutError')
+            return 'timeout';
+        if (name === 'AbortError')
+            return 'aborted';
+    }
+    return 'transport_error';
+}
+function safeOperation(method) {
+    return /^[a-z][a-z0-9_.-]{0,79}$/.test(method) ? method : 'management';
+}
 /** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
 export async function coworkHttpCall(profile, method, params, timeoutMs) {
     const id = randomUUID();
@@ -9,11 +42,15 @@ export async function coworkHttpCall(profile, method, params, timeoutMs) {
     const body = JSON.stringify({ version: 1, id, method, params });
     if (Buffer.byteLength(body) > 1024 * 1024)
         throw new CoworkProtocolError(method, 'request exceeded 1 MiB');
+    let stage = 'server verification';
     try {
         const client = await attachOursClient({ endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
             credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken: `fleet-cowork-check-${id}`, env: {}, requestSignal: signal });
+        stage = 'verification cleanup';
         await client.close();
+        stage = 'credential read';
         const token = readPrivateFile(profile.credentialPath, 4096).toString('utf8').trim();
+        stage = 'management request';
         const response = await fetch(profile.serverUrl + '/cowork/management/rpc', {
             method: 'POST', redirect: 'error', signal,
             headers: { 'content-type': 'application/json', 'x-ours-api-token': token },
@@ -26,6 +63,7 @@ export async function coworkHttpCall(profile, method, params, timeoutMs) {
         const reader = response.body?.getReader();
         if (!reader)
             throw new CoworkProtocolError(method, 'empty HTTP response');
+        stage = 'management response';
         const chunks = [];
         let size = 0;
         try {
@@ -42,16 +80,25 @@ export async function coworkHttpCall(profile, method, params, timeoutMs) {
         finally {
             await reader.cancel();
         }
+        // Status and media type, never the body: a proxy page may echo request data.
+        const shape = `HTTP ${response.status}, ${safeContentType(response)}`;
         let rpc;
+        let malformed = false;
         try {
             rpc = JSON.parse(Buffer.concat(chunks).toString('utf8'));
         }
         catch {
-            throw new CoworkProtocolError(method, 'server returned malformed JSON');
+            malformed = true;
+        }
+        if (malformed || !rpc || Array.isArray(rpc) || rpc.version !== 1 || rpc.id !== id
+            || Object.hasOwn(rpc, 'result') === Object.hasOwn(rpc, 'error')) {
+            // A gateway whose Cowork upstream is still starting answers with its own
+            // error page. That is unavailability, not a Cowork protocol violation; a
+            // well-formed RPC error under the same status keeps its meaning below.
+            if (GATEWAY_UNAVAILABLE.has(response.status))
+                throw new CoworkUnavailableError(`Cowork HTTP ${safeOperation(method)} failed: gateway answered ${shape} without an RPC response`, { retryable: true });
+            throw new CoworkProtocolError(method, `server returned ${malformed ? 'malformed JSON' : 'an invalid RPC response'} (${shape})`);
         }
-        if (!rpc || Array.isArray(rpc) || rpc.version !== 1 || rpc.id !== id
-            || Object.hasOwn(rpc, 'result') === Object.hasOwn(rpc, 'error'))
-            throw new CoworkProtocolError(method, 'server returned an invalid RPC response');
         if (Object.hasOwn(rpc, 'error')) {
             const error = rpc.error;
             if (!error || typeof error.code !== 'string' || typeof error.message !== 'string')
@@ -63,8 +110,11 @@ export async function coworkHttpCall(profile, method, params, timeoutMs) {
         return rpc.result;
     }
     catch (error) {
-        if (error instanceof CoworkProtocolError)
+        if (error instanceof CoworkProtocolError || error instanceof CoworkUnavailableError)
             throw error;
-        throw new CoworkUnavailableError('Cowork HTTP management failed; check the selected server and credential', { cause: error });
+        // Durable cleanup records retain only .message. Keep the RPC step and a
+        // bounded allowlisted category there, never raw URLs, credentials or cause text.
+        const kind = safeFailureKind(error, signal);
+        throw new CoworkUnavailableError(`Cowork HTTP ${safeOperation(method)} failed during ${stage} (${kind})`, { cause: error, retryable: stage !== 'credential read' && RETRYABLE_KINDS.has(kind) });
     }
 }

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

@@ -3,7 +3,7 @@ import { type CoworkAdapter } from './cowork-adapter.js';
 import { type TaskDeletionAcceptance } from './task-state.js';
 import type { TaskDeletionActor, TaskRecord } from './types.js';
 export { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
-type DeletionCowork = Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'>;
+type DeletionCowork = Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'> & Partial<Pick<CoworkAdapter, 'getRoom'>>;
 export interface TaskDeletionSettleDeps {
     roomClose?: RoomCloseDeps;
     /** Test seam for the temp-state existence proof. */

package/dist/rooms-tasks/deletion.js

@@ -1,13 +1,20 @@
+import { eraseMemberArtifacts } from './erasure.js';
+import { assertMemberNotPermanent } from './member-ownership.js';
+import { retireTaskMemberService } from './task-service-retirement.js';
+import { assertTaskRegistrationsAbsent } from '../supervisor/catalog.js';
+import { proveArchivedAbsence, verifyArchivedAbsence, verifyArchivedMemberStillAbsent } from './archived-absence.js';
 import { existsSync } from 'node:fs';
 import { withFileLock } from '../atomic-file.js';
 import { agentDir } from '../paths.js';
+import { deleteWorkspace, assertWorkspaceDeletable } from './workspace.js';
+import { collectWorkspaceArchives } from './workspace-artifacts.js';
 import { secureStoppedTempArchive, stopTempSupervisor } from '../temp-lifecycle.js';
-import { closeManagedRoom, identityCidPresent, inspectMember, removeExactMemberIdentity, waitForLivenessAbsent, } from './close.js';
+import { closeManagedRoom, identityCidPresent, inspectMember, assertMemberIdentityAbsent, removeExactMemberIdentity, waitForLivenessAbsent, } from './close.js';
 import { CoworkProtocolError } from './cowork-adapter.js';
 import { deleteRoomRecord, getRoomRecord, listRoomRecords } from './room-state.js';
 import { acquireLaunchSnapshotLock, releaseLaunchSnapshotForDeletingTask } from './launch-snapshot.js';
 import { TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath } from './terminal.js';
-import { advanceTaskDeletionMember, beginTaskDeletionIntent, completeTaskDeletionReceipt, ensureTaskDeletionReceipt, getDeletingTask, importTaskDeletionRetirementEvidence, setTaskDeletionError, TaskStateError, unlinkDeletedTask, upsertTaskDeletionMembersFromSeats, } from './task-state.js';
+import { advanceTaskDeletionMember, settleAbsentTaskDeletionMember, beginTaskDeletionIntent, completeTaskDeletionReceipt, ensureTaskDeletionReceipt, getDeletingTask, importTaskDeletionRetirementEvidence, setTaskDeletionError, TaskStateError, beginTaskArchiveCleanup, unlinkDeletedTask, upsertTaskDeletionMembersFromSeats, } from './task-state.js';
 export { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 import { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 /**
@@ -40,6 +47,7 @@ function tolerantCowork(cowork) {
         }
     };
     return {
+        ...(cowork.getRoom ? { getRoom: cowork.getRoom.bind(cowork) } : {}),
         closeRoom: roomId => tolerate(() => cowork.closeRoom(roomId)),
         deleteRoom: roomId => tolerate(() => cowork.deleteRoom(roomId)),
     };
@@ -48,6 +56,7 @@ function cursorSeat(cursor) {
     return {
         role_name: cursor.name, identity_cid: cursor.identity_cid,
         slot: cursor.name, cowork_role: 'member', seat_state: 'active',
+        ...(cursor.launch_id ? { retirement: { phase: 'identity_absent', launch_id: cursor.launch_id, archive_path: cursor.archive_path, updated_at: cursor.updated_at } } : {}),
     };
 }
 /**
@@ -58,10 +67,23 @@ function cursorSeat(cursor) {
  * the recorded CID surviving under any name blocks settlement.
  */
 async function retireCursorMember(taskId, cursor, deps) {
+    assertMemberNotPermanent(cursor.name);
+    await (deps.roomClose?.retireTaskService ?? retireTaskMemberService)(cursor.name, { taskId,
+        creationActionId: cursor.action_id,
+        taskSupervised: cursor.task_supervised,
+        ...((cursor.launch_id && !['never-launched', 'absent-verified'].includes(cursor.launch_id)) ? { launchId: cursor.launch_id } : {}),
+    });
     let phase = cursor.phase;
     let launchId = cursor.launch_id;
-    if (phase === 'identity_absent')
+    if (phase === 'identity_absent') {
+        if (!deps.roomClose?.inspectMember) {
+            if ((deps.hasTempState ?? (name => existsSync(agentDir(name, true))))(cursor.name))
+                throw new Error('Retired deletion member has replacement live state');
+            if (await (deps.identityCidPresent ?? identityCidPresent)(cursor.identity_cid))
+                throw new Error('Retired deletion member identity reappeared');
+        }
         return;
+    }
     const seat = cursorSeat(cursor);
     const roomClose = deps.roomClose ?? {};
     if (phase === 'pending') {
@@ -85,7 +107,16 @@ async function retireCursorMember(taskId, cursor, deps) {
         phase = 'stop_requested';
         launchId = ownership.launchId;
     }
+    if (!roomClose.inspectMember && !existsSync(agentDir(cursor.name, true))) {
+        await (roomClose.removeIdentity ?? removeExactMemberIdentity)(seat);
+        if (existsSync(agentDir(cursor.name, true)))
+            throw new Error('Deletion member acquired replacement state');
+        settleAbsentTaskDeletionMember(taskId, cursor.name);
+        return;
+    }
     if (phase === 'stop_requested') {
+        if (!roomClose.inspectMember && (await inspectMember(seat)).launchId !== launchId)
+            throw new Error('Deletion member launch changed before stop');
         await (roomClose.requestStop
             ?? (async (role) => { await stopTempSupervisor(role); }))(cursor.name);
         await (roomClose.waitForLivenessAbsent ?? waitForLivenessAbsent)(cursor.name, launchId);
@@ -145,10 +176,40 @@ export async function settleTaskDeletion(input) {
                 upsertTaskDeletionMembersFromSeats(taskId, record.member_seats);
                 await closeManagedRoom({ roomId: record.room_id, cowork: cowork, deps: deps.roomClose });
                 const closed = getRoomRecord(record.room_id);
-                importTaskDeletionRetirementEvidence(taskId, closed?.member_seats ?? record.member_seats);
+                const seats = closed?.member_seats ?? record.member_seats;
+                const proofs = [];
+                for (const seat of seats) {
+                    if (!seat.identity_cid && !seat.retirement?.absence_verified && !['never-launched', 'absent-verified'].includes(seat.retirement?.launch_id ?? '')) {
+                        const prior = task.deletion.archived_absences?.find(proof => proof.name === seat.role_name);
+                        if (task.deletion.workspace_cleanup_started_at && prior && !existsSync(prior.archive_path)) {
+                            await verifyArchivedMemberStillAbsent(prior);
+                            proofs.push(prior);
+                        }
+                        else
+                            proofs.push(await proveArchivedAbsence(seat));
+                    }
+                }
+                // No await between the last live-state fence and durable checkpoint.
+                for (const proof of proofs) {
+                    const latest = getRoomRecord(record.room_id)?.member_seats.find(seat => seat.role_name === proof.name);
+                    if (existsSync(agentDir(proof.name, true)) || latest?.identity_cid
+                        || latest?.launch?.launch_id !== proof.launch_id || latest.launch.action_id !== proof.action_id)
+                        throw new Error('Archived absence seat changed before checkpoint');
+                }
+                importTaskDeletionRetirementEvidence(taskId, seats, proofs);
                 await cowork.deleteRoom(record.room_id);
+                for (const proof of proofs)
+                    await (task.deletion.workspace_cleanup_started_at && !existsSync(proof.archive_path) ? verifyArchivedMemberStillAbsent : verifyArchivedAbsence)(proof);
+                beginTaskArchiveCleanup(taskId);
+                await eraseMemberArtifacts('room', record.room_id, seats, [record.room_id]);
+                for (const proof of proofs)
+                    if (existsSync(agentDir(proof.name, true)))
+                        throw new Error('Archived member replacement before room unlink');
                 deleteRoomRecord(record.room_id);
             }
+            const deletion = getDeletingTask(taskId).deletion;
+            for (const proof of deletion.archived_absences ?? [])
+                await (deletion.workspace_cleanup_started_at && !existsSync(proof.archive_path) ? verifyArchivedMemberStillAbsent : verifyArchivedAbsence)(proof);
             // Members whose room record is gone (crash after record deletion, or
             // legacy state): resume from the durable cursors.
             for (const cursor of getDeletingTask(taskId).deletion.members) {
@@ -176,7 +237,7 @@ export async function settleTaskDeletion(input) {
         completeTaskDeletionReceipt(taskId);
         return { task_id: taskId, deleted: false };
     }
-    const finalize = () => withFileLock(taskOperationLockPath(taskId), () => {
+    const finalize = () => withFileLock(taskOperationLockPath(taskId), async () => {
         try {
             const task = getDeletingTask(taskId);
             if (task.deletion?.status !== 'pending')
@@ -185,8 +246,26 @@ export async function settleTaskDeletion(input) {
                 throw new TaskStateError(`task ${taskId} room records reappeared during deletion finalization`);
             if (task.deletion.members.some(member => member.phase !== 'identity_absent'))
                 throw new TaskStateError(`task ${taskId} has unretired members at deletion finalization`);
+            for (const proof of task.deletion.archived_absences ?? [])
+                await (task.deletion.workspace_cleanup_started_at && !existsSync(proof.archive_path) ? verifyArchivedMemberStillAbsent : verifyArchivedAbsence)(proof);
+            for (const proof of task.deletion.archived_absences ?? [])
+                if (existsSync(agentDir(proof.name, true)))
+                    throw new Error('Archived member replacement before task unlink');
+            for (const name of task.deletion.absent_members ?? []) {
+                if (existsSync(agentDir(name, true)))
+                    throw new Error('Absent member acquired replacement state');
+                await assertMemberIdentityAbsent({ role_name: name, slot: name, cowork_role: 'member', seat_state: 'removed' });
+            }
             if (cleanup.snapshotHash)
                 releaseLaunchSnapshotForDeletingTask(cleanup.snapshotHash, taskId);
+            assertTaskRegistrationsAbsent(taskId);
+            await eraseMemberArtifacts('task', taskId, task.deletion.members.map(cursorSeat), task.deletion.room_id ? [task.deletion.room_id] : []);
+            if (task.workspace) {
+                assertWorkspaceDeletable(task.workspace, 'task', taskId);
+                beginTaskArchiveCleanup(taskId);
+                collectWorkspaceArchives(task.workspace);
+                deleteWorkspace(task.workspace, 'task', taskId);
+            }
             unlinkDeletedTask(taskId);
         }
         catch (error) {

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

@@ -0,0 +1,6 @@
+import type { RoomMemberSeat } from './types.js';
+/** Erase only proven launch artifacts. Each atomic rename transfers ownership to
+ * a random, durable tombstone before recursive removal can destroy its proof.
+ * The caller holds the task/room lifecycle lock and has retired all writers.
+ */
+export declare function eraseMemberArtifacts(owner: 'room' | 'task', id: string, seats: readonly RoomMemberSeat[], roomIds: readonly string[]): Promise<void>;

package/dist/rooms-tasks/erasure.js

@@ -0,0 +1,173 @@
+import { eraseResourcePresentations } from '../erased-resources.js';
+import { assertMemberNotPermanent } from './member-ownership.js';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { dirname, join, relative } from 'node:path';
+import { parse } from 'yaml';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { agentDir, stateRoot } from '../paths.js';
+import { readTempSupervisorForScan, tempSupervisorLiveness, eraseTerminationEvents } from '../temp-lifecycle.js';
+import { assertSafeAncestors, auditWorkspaceGit, prepareOwnedDeletionTree } from './workspace.js';
+function entries(path) {
+    try {
+        return readdirSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+function json(path) {
+    try {
+        if (!lstatSync(path).isFile() || lstatSync(path).isSymbolicLink())
+            return undefined;
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function fingerprint(path) {
+    const stat = lstatSync(path);
+    const files = stat.isDirectory() ? ['creation.json', '.temp-supervisor.json', '.identity', 'role.yaml', 'state.json', 'instance.json'] : [''];
+    const hash = createHash('sha256');
+    for (const file of files) {
+        const target = file ? join(path, file) : path;
+        if (existsSync(target)) {
+            if (!lstatSync(target).isFile() || lstatSync(target).isSymbolicLink())
+                throw new Error('Unsafe erasure proof');
+            hash.update(file).update(readFileSync(target));
+        }
+    }
+    return hash.digest('hex');
+}
+/** Erase only proven launch artifacts. Each atomic rename transfers ownership to
+ * a random, durable tombstone before recursive removal can destroy its proof.
+ * The caller holds the task/room lifecycle lock and has retired all writers.
+ */
+export async function eraseMemberArtifacts(owner, id, seats, roomIds) {
+    if (!/^[a-zA-Z0-9_-]{1,80}$/.test(id))
+        throw new Error('Invalid erasure owner');
+    const root = stateRoot();
+    const manifestPath = join(root, 'erasure', `${owner}-${id}.json`);
+    assertSafeAncestors(dirname(manifestPath));
+    let manifest = json(manifestPath);
+    const names = new Set(seats.map(s => s.role_name));
+    for (const name of names) {
+        if (!/^[a-zA-Z0-9_-]{1,120}$/.test(name))
+            throw new Error('Invalid erasure member');
+        assertMemberNotPermanent(name);
+        if (existsSync(agentDir(name, true)))
+            throw new Error(`Member '${name}' still has live state during erasure`);
+    }
+    if (!manifest) {
+        const paths = [];
+        const launches = seats.flatMap(seat => {
+            const launchId = seat.launch?.launch_id ?? seat.retirement?.launch_id;
+            return launchId ? [{ role: seat.role_name, launchId }] : [];
+        });
+        const actions = new Map(seats.map(s => [s.role_name, new Set([s.launch?.action_id].filter((v) => !!v))]));
+        const recovery = join(root, 'recovery', 'temporary');
+        assertSafeAncestors(recovery);
+        for (const entry of entries(recovery)) {
+            const path = join(recovery, entry);
+            const stat = lstatSync(path);
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                continue;
+            const supervisor = readTempSupervisorForScan(path);
+            if (!supervisor || !names.has(supervisor.role))
+                continue;
+            const seat = seats.find(s => s.role_name === supervisor.role);
+            const creation = json(join(path, 'creation.json'));
+            let room;
+            const roleFile = join(path, 'role.yaml');
+            if (existsSync(roleFile) && lstatSync(roleFile).isFile() && !lstatSync(roleFile).isSymbolicLink()) {
+                const role = parse(readFileSync(roleFile, 'utf8'));
+                if (role?.name === supervisor.role)
+                    room = role.roomMemberStartup?.room_id;
+            }
+            const exactLaunch = seat.launch?.launch_id === supervisor.launchId || seat.retirement?.launch_id === supervisor.launchId;
+            const exactAction = creation?.role === supervisor.role && creation.creationActionId === seat.launch?.action_id;
+            // Older attempts belong only when the launch descriptor pins the room.
+            if (!(exactLaunch && (exactAction || !seat.launch?.action_id)) && !(room && roomIds.includes(room)))
+                continue;
+            if (existsSync(join(path, '.identity')) && readFileSync(join(path, '.identity'), 'utf8').trim() !== supervisor.role)
+                throw new Error('Archive identity mismatch during erasure');
+            if (await tempSupervisorLiveness(path) !== 'stopped')
+                throw new Error('Archive writer is not stopped');
+            if (creation?.role === supervisor.role && typeof creation.creationActionId === 'string')
+                actions.get(supervisor.role).add(creation.creationActionId);
+            auditWorkspaceGit(path, { forDeletion: true });
+            launches.push({ role: supervisor.role, launchId: supervisor.launchId });
+            paths.push(path);
+        }
+        const privateRoot = join(root, 'private-ours');
+        assertSafeAncestors(privateRoot);
+        for (const entry of entries(privateRoot)) {
+            const path = join(privateRoot, entry);
+            if (!lstatSync(path).isDirectory() || lstatSync(path).isSymbolicLink())
+                continue;
+            if (entry === 'launches' || entry === 'room-inputs') {
+                for (const file of entries(path)) {
+                    const child = join(path, file), value = json(child);
+                    if (!value)
+                        continue;
+                    const launchOwned = entry === 'launches' && value.role === value.identity
+                        && actions.get(value.role)?.has(value.action);
+                    const roomOwned = entry === 'room-inputs' && roomIds.includes(value.room_id)
+                        && names.has(value.identity_name);
+                    const readyOwned = entry === 'room-inputs' && file.endsWith('.ready.json')
+                        && roomIds.includes(value.room) && seats.some(seat => seat.invite_id === value.invite && (!seat.identity_cid || seat.identity_cid === value.cid));
+                    if (launchOwned || roomOwned || readyOwned)
+                        paths.push(child);
+                }
+                continue;
+            }
+            const state = json(join(path, 'state.json')), instance = json(join(path, 'instance.json'));
+            if (state?.lifetime === 'temporary' && actions.get(state.name)?.has(state.action)
+                && instance?.role === state.name && instance?.temporary === true && instance?.instance === state.instance) {
+                auditWorkspaceGit(path, { forDeletion: true });
+                paths.push(path);
+            }
+        }
+        manifest = { launches, version: 1, token: randomUUID(), paths, phases: {}, stamps: Object.fromEntries(paths.map(path => {
+                const stat = lstatSync(path);
+                return [path, { dev: stat.dev, ino: stat.ino, proof: fingerprint(path) }];
+            })) };
+        mkdirSync(dirname(manifestPath), { recursive: true, mode: 0o700 });
+        replaceFileAtomically(manifestPath, JSON.stringify(manifest));
+    }
+    if (manifest.version !== 1 || !/^[a-f0-9-]{36}$/.test(manifest.token) || !Array.isArray(manifest.paths))
+        throw new Error('Invalid erasure manifest');
+    for (const path of manifest.paths) {
+        const rel = relative(root, path);
+        if (!rel.startsWith('recovery/temporary/') && !rel.startsWith('private-ours/'))
+            throw new Error('Invalid erasure artifact path');
+        if (rel.split('/').includes('..'))
+            throw new Error('Invalid erasure artifact traversal');
+        assertSafeAncestors(dirname(path));
+        const tombstone = `${path}.erasing-${manifest.token}`;
+        if (manifest.phases[path] === 'removed')
+            continue;
+        if (existsSync(path) && !existsSync(tombstone) && manifest.phases[path] !== 'renamed') {
+            const stat = lstatSync(path), stamp = manifest.stamps[path];
+            if (stat.isSymbolicLink() || !stamp || stamp.dev !== stat.dev || stamp.ino !== stat.ino || stamp.proof !== fingerprint(path))
+                throw new Error('Erasure source ownership changed');
+            renameSync(path, tombstone);
+        }
+        manifest.phases[path] = 'renamed';
+        replaceFileAtomically(manifestPath, JSON.stringify(manifest));
+        if (existsSync(tombstone) && lstatSync(tombstone).isDirectory())
+            prepareOwnedDeletionTree(tombstone);
+        rmSync(tombstone, { recursive: true, force: true });
+        manifest.phases[path] = 'removed';
+        replaceFileAtomically(manifestPath, JSON.stringify(manifest));
+    }
+    eraseResourcePresentations([{ kind: owner, id }, ...roomIds.map(id => ({ kind: 'room', id })),
+        ...seats.map(seat => ({ kind: 'agent', id: seat.role_name }))]);
+    eraseTerminationEvents(manifest.launches);
+    rmSync(manifestPath, { force: true });
+}

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,8 +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',
-        'OURS_PORT', 'OURS_STATE_DIR', 'OURS_API_TOKEN', 'OURS_COWORK_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]
@@ -52,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);