@ours.network/fleet 1.2.0-nightly.2 → 1.2.0-nightly.21

package/dist/rooms-tasks/config.js

@@ -54,7 +54,9 @@ export function validateRoomsConfig(raw, vars, path) {
         if (!isPlainObject(raw.cowork))
             throw new RoomsTasksConfigError(path, 'rooms.cowork: must be a mapping');
         rejectUnknown(raw.cowork, RCK, path, 'rooms.cowork');
-        cowork = { config: raw.cowork.config };
+        if (raw.cowork.config !== undefined)
+            throw new RoomsTasksConfigError(path, 'rooms.cowork.config is no longer supported; remove it and configure ~/.ours-client/profile.json for all services');
+        cowork = {};
     }
     if (!isPlainObject(raw.owner))
         throw new RoomsTasksConfigError(path, 'rooms.owner: required and must be a mapping');

package/dist/rooms-tasks/cowork-adapter.d.ts

@@ -1,8 +1,8 @@
 /**
- * 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 type { Socket } from 'node:net';
 import type { RoomHistoryEvidence } from './types.js';
@@ -58,6 +58,10 @@ export interface CoworkAdapter {
         briefing: string;
         quiet_membership?: boolean;
         anonymous?: boolean;
+        activation_requirements?: Array<{
+            role: string;
+            count: number;
+        }>;
     }): Promise<CoworkRoomCreateResult>;
     acceptInvite(roomId: string, invite: string, opts: {
         role: string;
@@ -104,6 +108,4 @@ export interface CoworkAdapterOptions {
     home?: string;
     connect?: (path: string) => Socket;
 }
-/** Resolve the same config/state inputs as ours-cowork and return its Unix socket. */
-export declare function resolveCoworkSocketPath(options?: CoworkAdapterOptions): string;
 export declare function createCoworkAdapter(options?: CoworkAdapterOptions): CoworkAdapter;

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

@@ -1,18 +1,14 @@
 /**
- * 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';
-const RPC_VERSION = 1;
+import { readClientProfile } from '../client-profile.js';
+import { coworkHttpCall } from './cowork-http.js';
 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) {
+    constructor(message = 'Cowork gateway management is not reachable', options) {
         super(message, options);
         this.name = 'CoworkUnavailableError';
     }
@@ -169,116 +165,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 socketPath = resolveCoworkSocketPath(options);
+    const env = options.env ?? process.env;
+    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) => rpcCall(socketPath, method, params, timeoutMs, connect);
+    const call = (method, params) => coworkHttpCall(profile, method, params, timeoutMs);
     return {
         async available() {
             try {
@@ -296,6 +189,7 @@ export function createCoworkAdapter(options = {}) {
                 briefing: opts.briefing,
                 ...(opts.quiet_membership === undefined ? {} : { quiet_membership: opts.quiet_membership }),
                 ...(opts.anonymous === undefined ? {} : { anonymous: opts.anonymous }),
+                ...(opts.activation_requirements === undefined ? {} : { activation_requirements: opts.activation_requirements }),
             }), 'room.create');
             if (!result.identity_cid)
                 throw new CoworkProtocolError('room.create', 'created room did not establish an identity CID');

package/dist/rooms-tasks/cowork-http.d.ts

@@ -0,0 +1,3 @@
+import type { ExplicitClientProfile } from '../client-profile.js';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export declare function coworkHttpCall(profile: ExplicitClientProfile, method: string, params: Record<string, unknown>, timeoutMs: number): Promise<unknown>;

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

@@ -0,0 +1,70 @@
+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';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export async function coworkHttpCall(profile, method, params, timeoutMs) {
+    const id = randomUUID();
+    const signal = AbortSignal.timeout(timeoutMs);
+    const body = JSON.stringify({ version: 1, id, method, params });
+    if (Buffer.byteLength(body) > 1024 * 1024)
+        throw new CoworkProtocolError(method, 'request exceeded 1 MiB');
+    try {
+        const client = await attachOursClient({ endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken: `fleet-cowork-check-${id}`, env: {}, requestSignal: signal });
+        await client.close();
+        const token = readPrivateFile(profile.credentialPath, 4096).toString('utf8').trim();
+        const response = await fetch(profile.serverUrl + '/cowork/management/rpc', {
+            method: 'POST', redirect: 'error', signal,
+            headers: { 'content-type': 'application/json', 'x-ours-api-token': token },
+            body,
+        });
+        if (response.status === 401 || response.status === 403) {
+            await response.body?.cancel();
+            throw new CoworkProtocolError(method, 'server credential was rejected', 'unauthorized');
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new CoworkProtocolError(method, 'empty HTTP response');
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.length;
+                if (size > 4 * 1024 * 1024)
+                    throw new CoworkProtocolError(method, 'response exceeded 4 MiB');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+        let rpc;
+        try {
+            rpc = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch {
+            throw new CoworkProtocolError(method, 'server returned malformed JSON');
+        }
+        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')
+                throw new CoworkProtocolError(method, 'server returned an invalid RPC error');
+            throw new CoworkProtocolError(method, error.message, error.code);
+        }
+        if (!response.ok)
+            throw new CoworkProtocolError(method, `management answered HTTP ${response.status}`);
+        return rpc.result;
+    }
+    catch (error) {
+        if (error instanceof CoworkProtocolError)
+            throw error;
+        throw new CoworkUnavailableError('Cowork HTTP management failed; check the selected server and credential', { cause: error });
+    }
+}

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,17 @@
+import { eraseMemberArtifacts } from './erasure.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 +44,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 +53,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 } } : {}),
     };
 }
 /**
@@ -60,8 +66,15 @@ function cursorSeat(cursor) {
 async function retireCursorMember(taskId, cursor, deps) {
     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 +98,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 +167,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 +228,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 +237,25 @@ 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);
+            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,169 @@
+import { eraseResourcePresentations } from '../erased-resources.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 { readTempSupervisor, tempSupervisorLiveness, eraseTerminationEvents } from '../temp-lifecycle.js';
+import { assertSafeAncestors, auditWorkspaceGit } 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');
+        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 = readTempSupervisor(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);
+            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);
+                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));
+        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);

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

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