@ours.network/fleet 1.2.0-nightly.9 → 2.0.0

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,14 +1,21 @@
-import { proveArchivedAbsence, verifyArchivedAbsence } from './archived-absence.js';
+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';
+import { deleteTaskReviewStore } from './task-review.js';
 export { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 import { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 /**
@@ -41,6 +48,7 @@ function tolerantCowork(cowork) {
         }
     };
     return {
+        ...(cowork.getRoom ? { getRoom: cowork.getRoom.bind(cowork) } : {}),
         closeRoom: roomId => tolerate(() => cowork.closeRoom(roomId)),
         deleteRoom: roomId => tolerate(() => cowork.deleteRoom(roomId)),
     };
@@ -49,6 +57,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 } } : {}),
     };
 }
 /**
@@ -59,10 +68,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') {
@@ -86,7 +108,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);
@@ -149,8 +180,15 @@ export async function settleTaskDeletion(input) {
                 const seats = closed?.member_seats ?? record.member_seats;
                 const proofs = [];
                 for (const seat of seats) {
-                    if (!seat.identity_cid && seat.retirement?.launch_id !== 'never-launched')
-                        proofs.push(await proveArchivedAbsence(seat));
+                    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) {
@@ -162,14 +200,17 @@ export async function settleTaskDeletion(input) {
                 importTaskDeletionRetirementEvidence(taskId, seats, proofs);
                 await cowork.deleteRoom(record.room_id);
                 for (const proof of proofs)
-                    await verifyArchivedAbsence(proof);
+                    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);
             }
-            for (const proof of getDeletingTask(taskId).deletion.archived_absences ?? [])
-                await verifyArchivedAbsence(proof);
+            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) {
@@ -207,12 +248,27 @@ export async function settleTaskDeletion(input) {
             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 verifyArchivedAbsence(proof);
+                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);
+            }
+            // Retained To review files go with the task; the pending deletion already refuses new attachments.
+            deleteTaskReviewStore(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);

package/dist/rooms-tasks/layout-binding-client.d.ts

@@ -0,0 +1,11 @@
+import type { LayoutInstance } from './layout.js';
+import type { LayoutControlRequest } from './layout-control.js';
+export type LayoutBindingRequest = Omit<LayoutControlRequest, 'instance'> & {
+    roomId?: string;
+    roomRole?: string;
+};
+export declare const LAYOUT_BINDING_ACTIONS: readonly ["verify", "join", "assign"];
+export declare const localLayoutReference: ({ remote: _remote, ...instance }: LayoutInstance) => LayoutInstance;
+/** Initial support is the same-host, separate-OS-user use case from #194. */
+export declare function layoutBindingOrigin(raw: string): string;
+export declare function callRemoteLayoutBinding(instance: LayoutInstance, request: LayoutBindingRequest, daemonInstanceId: string, fetchImpl?: typeof fetch): Promise<unknown>;

package/dist/rooms-tasks/layout-binding-client.js

@@ -0,0 +1,56 @@
+import { lstatSync, readFileSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { canonicalJson } from '../canonical-json.js';
+export const LAYOUT_BINDING_ACTIONS = ['verify', 'join', 'assign'];
+export const localLayoutReference = ({ remote: _remote, ...instance }) => instance;
+/** Initial support is the same-host, separate-OS-user use case from #194. */
+export function layoutBindingOrigin(raw) {
+    const url = new URL(raw);
+    if (url.protocol !== 'http:' || !['127.0.0.1'].includes(url.hostname)
+        || url.username || url.password || url.pathname !== '/' || url.search || url.hash)
+        throw Error('cross-Fleet bindings require an explicit loopback HTTP origin');
+    return url.origin;
+}
+export async function callRemoteLayoutBinding(instance, request, daemonInstanceId, fetchImpl = fetch) {
+    const remote = instance.remote;
+    if (!LAYOUT_BINDING_ACTIONS.includes(request.action))
+        throw Error('cross-Fleet bindings allow only verify, join and assign');
+    if (remote.daemon_instance_id !== daemonInstanceId)
+        throw Error('cross-Fleet binding requires the same daemon instance');
+    const origin = layoutBindingOrigin(remote.url);
+    if (!/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(remote.grant_id) || !isAbsolute(remote.credential_file))
+        throw Error('invalid cross-Fleet binding');
+    const stat = lstatSync(remote.credential_file);
+    if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077)
+        || (process.getuid && stat.uid !== process.getuid()) || stat.size > 256)
+        throw Error('untrusted cross-Fleet credential file');
+    const token = readFileSync(remote.credential_file, 'utf8').trim();
+    if (!/^[A-Za-z0-9_-]{43}$/.test(token))
+        throw Error('invalid cross-Fleet credential');
+    let response;
+    try {
+        response = await fetchImpl(`${origin}/api/v1/layout-bindings/${remote.grant_id}/control`, {
+            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(60_000),
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+            body: JSON.stringify({ ...request, instance: localLayoutReference(instance), daemonInstanceId }),
+        });
+    }
+    catch {
+        throw Error('cross-Fleet control unavailable; operation outcome may be unknown');
+    }
+    // Remote errors are not trusted presentation data and may contain private request bytes.
+    if (!response.ok)
+        throw Error(`cross-Fleet binding rejected (${response.status})`);
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch {
+        throw Error('invalid cross-Fleet control response');
+    }
+    if (!result || typeof result !== 'object')
+        throw Error('invalid cross-Fleet control response');
+    if (canonicalJson(result.instance) !== canonicalJson(localLayoutReference(instance)))
+        throw Error('cross-Fleet instance proof changed');
+    return result.result;
+}

package/dist/rooms-tasks/layout-binding-grants.d.ts

@@ -0,0 +1,21 @@
+import type { LayoutInstance, LayoutSupervisor } from './layout.js';
+import { type CoworkAdapter } from './cowork-adapter.js';
+/** Private authorization records in the existing Fleet state; no foreign lifecycle port. */
+export declare class LayoutBindingGrants {
+    private supervisor;
+    private options;
+    constructor(supervisor: LayoutSupervisor, options?: {
+        root?: string;
+        daemonInstanceId?: () => string;
+        cowork?: () => CoworkAdapter;
+    });
+    private get root();
+    private daemonInstanceId;
+    private path;
+    share(instance: LayoutInstance, origin: string, output: string, participant: string): Promise<{
+        grant_id: string;
+        file: string;
+    }>;
+    revoke(id: string): Promise<void>;
+    control(id: string, authorization: string | undefined, raw: unknown): Promise<unknown>;
+}