@ours.network/fleet 1.2.0-nightly.13 → 1.2.0-nightly.14

package/dist/application/task-room-service.d.ts

@@ -282,6 +282,9 @@ export declare class TaskRoomApplicationService {
         actor: TaskRoomActor;
         roomId: string;
     }): Promise<{
+        room: undefined;
+        settlementRequired: true;
+    } | {
         room: RoomOrchestrationRecord;
         settlementRequired: true;
     }>;

package/dist/application/task-room-service.js

@@ -638,7 +638,7 @@ export class TaskRoomApplicationService {
             createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
         const room = getRoomRecord(input.roomId);
         if (!room) {
-            throw new TaskRoomApplicationError('room_record_not_found', 'room record not found', { room: input.roomId });
+            return { room: undefined, settlementRequired: true };
         }
         return { room: await acceptManagedRoomClose(input.roomId), settlementRequired: true };
     }

package/dist/atomic-file.d.ts

@@ -36,3 +36,8 @@ export declare function withFileLock<T>(lockPath: string, fn: () => T | Promise<
  * intact.
  */
 export declare function replaceFileAtomically(path: string, contents: string, mode?: number, deps?: WriteDeps): void;
+/** Synchronous Lamport bakery lock: unique claims are never reused, so stale
+ * reclamation cannot remove a successor's lock. Atomic claim replacement keeps
+ * choosing/ticket reads complete. Dead claims can be removed by any contender.
+ */
+export declare function withSynchronousFileLock<T>(path: string, work: () => T): T;

package/dist/atomic-file.js

@@ -1,4 +1,4 @@
-import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, writeSync, } from 'node:fs';
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, writeSync, } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 const DEFAULT_STALE_MS = 10_000;
@@ -136,3 +136,64 @@ export function replaceFileAtomically(path, contents, mode = 0o600, deps = {}) {
     }
     catch { /* platform does not allow fsync on a directory */ }
 }
+/** Synchronous Lamport bakery lock: unique claims are never reused, so stale
+ * reclamation cannot remove a successor's lock. Atomic claim replacement keeps
+ * choosing/ticket reads complete. Dead claims can be removed by any contender.
+ */
+export function withSynchronousFileLock(path, work) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    const token = `${process.pid}-${randomUUID()}.json`;
+    const own = join(path, token);
+    const deadline = Date.now() + 10_000;
+    const claims = () => {
+        const result = [];
+        for (const name of readdirSync(path).filter(name => /^[0-9]+-[a-f0-9-]{36}\.json$/.test(name))) {
+            const file = join(path, name);
+            let value;
+            try {
+                value = JSON.parse(readFileSync(file, 'utf8'));
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            if (!Number.isSafeInteger(value.pid) || value.pid <= 0 || !Number.isSafeInteger(value.ticket) || value.ticket < 0)
+                throw new Error('Invalid synchronous lock claim');
+            if (name !== token) {
+                try {
+                    process.kill(value.pid, 0);
+                }
+                catch (error) {
+                    if (error.code === 'ESRCH') {
+                        // This dead contender alone owned this UUID path. Never remove
+                        // the namespace or a successor's differently named claim.
+                        rmSync(file, { force: true });
+                        continue;
+                    }
+                }
+            }
+            result.push({ name, value });
+        }
+        return result;
+    };
+    replaceFileAtomically(own, JSON.stringify({ pid: process.pid, choosing: true, ticket: 0 }));
+    try {
+        const ticket = Math.max(0, ...claims().map(claim => claim.value.ticket)) + 1;
+        if (!Number.isSafeInteger(ticket))
+            throw new Error('Synchronous lock ticket overflow');
+        replaceFileAtomically(own, JSON.stringify({ pid: process.pid, choosing: false, ticket }));
+        for (;;) {
+            const preceding = claims().some(claim => claim.name !== token && (claim.value.choosing
+                || claim.value.ticket < ticket || (claim.value.ticket === ticket && claim.name < token)));
+            if (!preceding)
+                return work();
+            if (Date.now() >= deadline)
+                throw new Error('Timed out acquiring synchronous journal lock');
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+    finally {
+        rmSync(own, { force: true });
+    }
+}

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.13",
-  "buildId": "3385b7b09b31",
-  "commit": "76ea214e69c007a06469b0defee3634779434657",
+  "version": "1.2.0-nightly.14",
+  "buildId": "b88d0d158cc7",
+  "commit": "717f6d8a09e6173b9b8a017fc5efb08d71927524",
   "dirty": true,
-  "builtAt": "2026-09-24T13:41:37.102Z",
+  "builtAt": "2026-09-24T14:15:57.206Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/erased-resources.d.ts

@@ -0,0 +1,9 @@
+export declare const erasedArg: (value: string) => string;
+export declare function redactErasedContent<T>(value: T): T;
+/** Every cooperative writer filters stale in-memory snapshots under the same lock as erasure. */
+export declare function writePrivacyFilteredLedger(path: string, value: unknown): void;
+/** Content-free resource IDs persist to prevent active writers resurrecting erased labels. */
+export declare function eraseResourcePresentations(resources: ReadonlyArray<{
+    kind: 'task' | 'room' | 'agent';
+    id: string;
+}>): void;

package/dist/erased-resources.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically, withSynchronousFileLock } from './atomic-file.js';
+import { stateRoot } from './paths.js';
+const registryPath = () => join(stateRoot(), 'erased-resources.json');
+const lockPath = () => join(stateRoot(), 'locks', 'audit-erasure');
+const ledgerNames = ['.fleet-command-audit.json', '.owner-channel-command-audit.json', '.owner-channel-lifecycle-outbox.json'];
+export const erasedArg = (value) => `[erased:${createHash('sha256').update(value).digest('hex')}]`;
+function registry() {
+    if (!existsSync(registryPath()))
+        return new Set();
+    const value = JSON.parse(readFileSync(registryPath(), 'utf8'));
+    if (!Array.isArray(value) || value.some(v => typeof v !== 'string'))
+        throw new Error('Invalid erasure registry');
+    return new Set(value);
+}
+/** Preserve delivery/deduplication metadata while removing owned presentation content. */
+function redact(value, erased) {
+    if (Array.isArray(value))
+        return value.map(item => redact(item, erased));
+    if (!value || typeof value !== 'object')
+        return value;
+    const next = { ...value };
+    const kind = value.kind === 'lifecycle_failure' ? value.resource?.toLowerCase() : value.kind === 'agent_started' ? 'agent' : value.kind;
+    if (typeof value.id === 'string' && erased.has(`${kind}:${value.id}`)) {
+        for (const key of ['title', 'reason', 'roomName', 'label', 'template', 'configuration', 'model', 'permissions'])
+            delete next[key];
+        if (kind === 'task')
+            next.agents = [];
+        if (kind === 'room') {
+            delete next.name;
+            next.participants = [];
+        }
+        if (kind === 'agent') {
+            next.name = 'erased';
+            next.brain = '[erased]';
+            next.role = '[erased]';
+            next.inherited = [];
+        }
+    }
+    if (typeof value.roomId === 'string' && erased.has(`room:${value.roomId}`)) {
+        delete next.roomName;
+        if (kind === 'task')
+            next.agents = [];
+    }
+    const resources = value.outcome?.resourceIds;
+    const ownsAttempt = resources && Object.entries(resources).some(([key, id]) => erased.has(`${key}:${id}`));
+    const ownsPresentation = value.outcome?.presentations?.some((p) => erased.has(`${p.kind === 'agent_started' ? 'agent' : p.kind}:${p.id}`));
+    if ((ownsAttempt || ownsPresentation) && Array.isArray(value.argv) && !value.erased) {
+        next.argv = value.argv.map(erasedArg);
+        next.erased = true;
+    }
+    for (const key of Object.keys(next))
+        if (typeof next[key] === 'object')
+            next[key] = redact(next[key], erased);
+    return next;
+}
+export function redactErasedContent(value) { return redact(value, registry()); }
+/** Every cooperative writer filters stale in-memory snapshots under the same lock as erasure. */
+export function writePrivacyFilteredLedger(path, value) {
+    withSynchronousFileLock(lockPath(), () => replaceFileAtomically(path, JSON.stringify(redact(value, registry())) + '\n'));
+}
+/** Content-free resource IDs persist to prevent active writers resurrecting erased labels. */
+export function eraseResourcePresentations(resources) {
+    withSynchronousFileLock(lockPath(), () => {
+        const erased = registry();
+        for (const resource of resources)
+            erased.add(`${resource.kind}:${resource.id}`);
+        replaceFileAtomically(registryPath(), JSON.stringify([...erased]));
+        for (const root of [join(stateRoot(), 'agents'), join(stateRoot(), 'tmp'), join(stateRoot(), 'recovery', 'temporary')]) {
+            if (!existsSync(root))
+                continue;
+            for (const entry of readdirSync(root, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.isSymbolicLink())
+                    continue;
+                for (const name of ledgerNames) {
+                    const path = join(root, entry.name, name);
+                    if (!existsSync(path) || !lstatSync(path).isFile() || lstatSync(path).isSymbolicLink())
+                        continue;
+                    const old = JSON.parse(readFileSync(path, 'utf8'));
+                    replaceFileAtomically(path, JSON.stringify(redact(old, erased)) + '\n');
+                }
+            }
+        }
+    });
+}

package/dist/fleet-command-audit.d.ts

@@ -113,6 +113,7 @@ export interface FleetCommandClassification {
     decision: FleetCommandDecision;
 }
 export interface FleetAuditAttempt {
+    erased?: boolean;
     version: 1;
     correlationId: string;
     requestId: string;

package/dist/fleet-command-audit.js

@@ -1,7 +1,7 @@
+import { erasedArg, redactErasedContent, writePrivacyFilteredLedger } from './erased-resources.js';
 import { existsSync, readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { Buffer } from 'node:buffer';
-import { replaceFileAtomically } from './atomic-file.js';
 import { isSensitiveConfigKey } from './sensitive-config.js';
 import { mandatoryConfigurationFits } from './lifecycle-summary.js';
 import { MARKDOWN_MAX_BYTES, MARKDOWN_MAX_CODE_POINTS, markdownCode, markdownProse, } from './rooms-tasks/markdown.js';
@@ -91,7 +91,7 @@ export function recordFleetAuditPresentation(value) {
                 : value.kind === 'lifecycle_failure'
                     ? { label: fleetPresentationLabel(value.label) }
                     : {};
-        const presentation = structuredClone({ ...value, ...labels, eventId: basis });
+        const presentation = redactErasedContent(structuredClone({ ...value, ...labels, eventId: basis }));
         const digest = lifecycleEventDigestBasis(presentation);
         if (!collection.presentations.some(existing => lifecycleEventDigestBasis(existing) === digest))
             collection.presentations.push(presentation);
@@ -305,11 +305,12 @@ export class FleetCommandAuditStore {
         if (recovered)
             this.persist();
     }
-    list() { return this.attempts.map(item => structuredClone(item)); }
+    list() { return redactErasedContent(this.attempts).map(item => structuredClone(item)); }
     begin(requestId, caller, argv) {
+        this.attempts = redactErasedContent(this.attempts);
         const existing = this.attempts.find(item => item.caller === caller && item.requestId === requestId);
         if (existing) {
-            if (JSON.stringify(existing.argv) !== JSON.stringify(redactFleetArgv(argv)))
+            if (JSON.stringify(existing.argv) !== JSON.stringify(existing.erased ? redactFleetArgv(argv).map(erasedArg) : redactFleetArgv(argv)))
                 throw new Error('fleet command request ID was reused with different argv');
             return structuredClone(existing);
         }
@@ -329,6 +330,8 @@ export class FleetCommandAuditStore {
         return structuredClone(attempt);
     }
     finish(correlationId, caller, outcome) {
+        this.attempts = redactErasedContent(this.attempts);
+        outcome = redactErasedContent({ outcome }).outcome;
         const attempt = this.owned(correlationId, caller);
         if (!attempt.outcome)
             attempt.outcome = { ...outcome, completedAt: this.deps.now().toISOString(), delivery: 'sending' };
@@ -360,7 +363,8 @@ export class FleetCommandAuditStore {
         return attempt;
     }
     persist() {
-        replaceFileAtomically(this.path, `${JSON.stringify({ version: 1, attempts: this.attempts })}\n`, 0o600);
+        this.attempts = redactErasedContent(this.attempts);
+        writePrivacyFilteredLedger(this.path, { version: 1, attempts: this.attempts });
     }
 }
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;

package/dist/owner-channel/lifecycle-outbox.js

@@ -1,6 +1,6 @@
+import { redactErasedContent, writePrivacyFilteredLedger } from '../erased-resources.js';
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, readFileSync } from 'node:fs';
-import { replaceFileAtomically } from '../atomic-file.js';
 import { lifecycleEventDigestBasis, validateFleetAuditPresentations, } from '../fleet-command-audit.js';
 const DIGEST = /^[a-f0-9]{64}$/u;
 const LIMIT = 5_000;
@@ -63,7 +63,7 @@ export class FleetLifecycleOutbox {
     }
     pending() {
         this.assertHealthy();
-        return this.entries.filter(entry => entry.delivery === 'pending').map(entry => structuredClone(entry));
+        return redactErasedContent(this.entries).filter(entry => entry.delivery === 'pending').map(entry => structuredClone(entry));
     }
     finish(digest, delivery) {
         this.assertHealthy();
@@ -82,6 +82,7 @@ export class FleetLifecycleOutbox {
             throw new Error(this.corruptReason);
     }
     persist() {
-        replaceFileAtomically(this.path, `${JSON.stringify({ version: 1, entries: this.entries })}\n`, 0o600);
+        this.entries = redactErasedContent(this.entries);
+        writePrivacyFilteredLedger(this.path, { version: 1, entries: this.entries });
     }
 }

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

@@ -27,7 +27,7 @@ export declare function acceptManagedRoomClose(roomId: string): Promise<RoomOrch
 export declare function recordManagedRoomCloseError(roomId: string, error: string, recoveryHint: string): Promise<RoomOrchestrationRecord>;
 export declare function closeManagedRoom(input: {
     roomId: string;
-    cowork: Pick<CoworkAdapter, 'closeRoom'>;
+    cowork: Pick<CoworkAdapter, 'closeRoom'> & Partial<Pick<CoworkAdapter, 'getRoom'>>;
     deps?: RoomCloseDeps;
 }): Promise<RoomOrchestrationRecord>;
 export interface ManagedRoomDeleteResult {
@@ -41,6 +41,6 @@ export declare function deleteLegacyClosedRooms(input: {
 /** Retire live resources through the existing cursor, then delete retained state. */
 export declare function deleteManagedRoom(input: {
     roomId: string;
-    cowork: Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'>;
+    cowork: Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'> & Partial<Pick<CoworkAdapter, 'getRoom'>>;
     deps?: RoomCloseDeps;
 }): Promise<ManagedRoomDeleteResult>;

package/dist/rooms-tasks/close.js

@@ -1,3 +1,6 @@
+import { detachDeletedRoom } from './task-state.js';
+import { binderKey } from '../agent-ours/state.js';
+import { eraseMemberArtifacts } from './erasure.js';
 import { deleteWorkspace, assertWorkspaceDeletable } from './workspace.js';
 import { collectWorkspaceArchives } from './workspace-artifacts.js';
 import { existsSync, readFileSync } from 'node:fs';
@@ -9,7 +12,7 @@ import { agentDir, stateRoot } from '../paths.js';
 import { readClientProfile } from '../client-profile.js';
 import { readTempSupervisor, secureStoppedTempArchive, stopTempSupervisor, tempSupervisorLiveness, tempArchiveForLaunch, tempArchiveForCreationAction, } from '../temp-lifecycle.js';
 import { CoworkProtocolError } from './cowork-adapter.js';
-import { advanceMemberRetirement, advanceRoomClose, beginRoomClose, closeRoom, deleteRoomRecord, getRoomRecord, listRoomRecords, setRoomCloseError, } from './room-state.js';
+import { advanceMemberRetirement, advanceRoomClose, beginRoomClose, closeRoom, deleteRoomRecord, getRoomRecord, listRoomRecords, setRoomCloseError, recordRetirementMemberCids, } from './room-state.js';
 export const CLOSE_LOCK_STALE_MS = 5 * 60_000;
 const STOP_POLLS = 50;
 const STOP_POLL_MS = 100;
@@ -22,6 +25,20 @@ function errorText(error) {
 function exactMemberIdentity(seat) {
     const dir = agentDir(seat.role_name, true);
     const identityPath = join(dir, '.identity');
+    if (existsSync(dir) && !existsSync(identityPath) && seat.launch?.action_id && seat.launch.launch_id) {
+        const supervisor = readTempSupervisor(dir);
+        let creation;
+        try {
+            creation = JSON.parse(readFileSync(join(dir, 'creation.json'), 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (supervisor?.role === seat.role_name && supervisor.launchId === seat.launch.launch_id
+            && creation?.role === seat.role_name && creation.creationActionId === seat.launch.action_id)
+            return;
+    }
     if (!existsSync(dir) || !existsSync(identityPath)) {
         throw new Error(`room member '${seat.role_name}' has no live Fleet temp-state identity proof; refusing retirement`);
     }
@@ -33,7 +50,8 @@ function exactMemberIdentity(seat) {
 export async function inspectMember(seat) {
     exactMemberIdentity(seat);
     const supervisor = readTempSupervisor(agentDir(seat.role_name, true));
-    if (!supervisor || supervisor.role !== seat.role_name) {
+    if (!supervisor || supervisor.role !== seat.role_name
+        || (seat.launch?.launch_id && supervisor.launchId !== seat.launch.launch_id)) {
         throw new Error(`room member '${seat.role_name}' has no exact Fleet supervisor ownership proof`);
     }
     return { launchId: supervisor.launchId };
@@ -93,14 +111,19 @@ export async function identityCidPresent(cid) {
 }
 export async function removeExactMemberIdentity(seat) {
     await withIdentityClient(async (client) => {
-        const before = listedIdentity(await client.listIdentities(), seat.role_name);
-        if (!before)
+        const rows = await client.listIdentities();
+        const before = listedIdentity(rows, seat.role_name);
+        if (!before) {
+            if (rows.some(row => row.name === seat.role_name || (seat.identity_cid && 'cid' in row
+                && row.cid.toLowerCase() === seat.identity_cid.toLowerCase())))
+                throw new Error(`room member '${seat.role_name}' identity absence is not proven`);
             return;
+        }
         if (!seat.identity_cid) {
-            throw new Error(`room member '${seat.role_name}' exists without a recorded authenticated CID; refusing removal`);
+            throw new Error(`room member '${seat.role_name}' exists without a recorded authenticated CID; identity absence is not proven; refusing removal`);
         }
         if (before.cid?.toLowerCase() !== seat.identity_cid.toLowerCase()) {
-            throw new Error(`room member '${seat.role_name}' identity CID mismatch: recorded ${seat.identity_cid}, found ${before.cid ?? 'none'}`);
+            throw new Error(`room member '${seat.role_name}' identity absence is not proven: CID mismatch: recorded ${seat.identity_cid}, found ${before.cid ?? 'none'}`);
         }
         try {
             await client.removeIdentity({ name: seat.role_name });
@@ -115,8 +138,9 @@ export async function removeExactMemberIdentity(seat) {
             if (after)
                 throw error;
         }
-        const after = listedIdentity(await client.listIdentities(), seat.role_name);
-        if (after) {
+        const after = await client.listIdentities();
+        if (after.some(row => row.name === seat.role_name || (seat.identity_cid && 'cid' in row
+            && row.cid.toLowerCase() === seat.identity_cid.toLowerCase()))) {
             throw new Error(`room member '${seat.role_name}' identity still exists after remove_identity`);
         }
     });
@@ -135,9 +159,9 @@ async function retireMember(roomId, seat, deps) {
     let current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
     let retirement = current.retirement;
     if (retirement?.phase === 'identity_absent') {
-        if (current.launch?.launch_id && current.launch.launch_id !== retirement.launch_id) {
+        if (!deps.inspectMember) {
             if (existsSync(agentDir(current.role_name, true)))
-                throw new Error(`room member '${current.role_name}' has a replacement launch after retirement; retire that exact temporary role before retrying`);
+                throw new Error('Retired member has replacement launch live state');
             await assertMemberIdentityAbsent(current);
         }
         return;
@@ -146,6 +170,8 @@ async function retireMember(roomId, seat, deps) {
         if (!existsSync(agentDir(current.role_name, true)) && current.launch?.launch_id && current.launch.action_id) {
             const archived = tempArchiveForLaunch(current.role_name, current.launch.launch_id);
             const created = tempArchiveForCreationAction(current.role_name, current.launch.action_id);
+            if (archived && (!created || created.path !== archived || created.launchId !== current.launch.launch_id))
+                throw new Error('Archived member creation ownership mismatch');
             if (archived && created?.path === archived && created.launchId === current.launch.launch_id) {
                 if (readFileSync(join(archived, '.identity'), 'utf8').trim() !== current.role_name)
                     throw new Error(`room member '${current.role_name}' archive identity mismatch`);
@@ -153,6 +179,7 @@ async function retireMember(roomId, seat, deps) {
                     throw new Error(`room member '${current.role_name}' archived supervisor is not proven stopped`);
                 // A terminated launch can archive itself before room retirement begins.
                 // Accept its exact durable provenance only when no identity needs removal.
+                await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
                 await assertMemberIdentityAbsent(current);
                 const latest = getRoomRecord(roomId)?.member_seats.find(seat => seat.role_name === current.role_name);
                 if (existsSync(agentDir(current.role_name, true))
@@ -164,14 +191,6 @@ async function retireMember(roomId, seat, deps) {
                 return;
             }
         }
-        if (current.launch?.state === 'failed' && !existsSync(agentDir(current.role_name, true))) {
-            // A failure before applyRole (for example invite-secret validation) has
-            // no supervisor to stop or archive. Settle only proven absence; this
-            // path never removes an identity based on missing local evidence.
-            await assertMemberIdentityAbsent(current);
-            advanceMemberRetirement(roomId, current.role_name, 'identity_absent', 'failed-launch-absent');
-            return;
-        }
         if (current.launch?.state === 'pending' && current.launch.attempt === 0) {
             if (existsSync(agentDir(current.role_name, true))) {
                 throw new Error(`never-launched room member '${current.role_name}' unexpectedly has Fleet temp state`);
@@ -180,12 +199,31 @@ async function retireMember(roomId, seat, deps) {
             advanceMemberRetirement(roomId, current.role_name, 'identity_absent', 'never-launched');
             return;
         }
+        if (!deps.inspectMember && !existsSync(agentDir(current.role_name, true))) {
+            await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
+            if (existsSync(agentDir(current.role_name, true)))
+                throw new Error(`room member '${current.role_name}' acquired replacement state during retirement`);
+            advanceMemberRetirement(roomId, current.role_name, 'identity_absent', 'absent-verified');
+            return;
+        }
         const ownership = await (deps.inspectMember ?? inspectMember)(current);
         room = advanceMemberRetirement(roomId, current.role_name, 'stop_requested', ownership.launchId);
         current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
         retirement = current.retirement;
     }
+    if (['stop_requested', 'liveness_absent', 'archive_secured'].includes(retirement.phase) && !deps.requestStop
+        && !existsSync(agentDir(current.role_name, true))) {
+        const archive = tempArchiveForLaunch(current.role_name, retirement.launch_id);
+        if (archive && await tempSupervisorLiveness(archive) !== 'stopped')
+            throw new Error('Archived supervisor is not proven stopped');
+        await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
+        await assertMemberIdentityAbsent(current);
+        advanceMemberRetirement(roomId, current.role_name, 'identity_absent', retirement.launch_id, archive, !archive);
+        return;
+    }
     if (retirement.phase === 'stop_requested') {
+        if (!deps.inspectMember && (await inspectMember(current)).launchId !== retirement.launch_id)
+            throw new Error('Member launch changed before stop');
         await (deps.requestStop ?? (async (role) => { await stopTempSupervisor(role); }))(current.role_name);
         await (deps.waitForLivenessAbsent ?? waitForLivenessAbsent)(current.role_name, retirement.launch_id);
         room = advanceMemberRetirement(roomId, current.role_name, 'liveness_absent', retirement.launch_id);
@@ -215,17 +253,31 @@ export async function closeManagedRoom(input) {
     const lock = deps.lock ?? withFileLock;
     return lock(roomCloseLockPath(input.roomId), async () => {
         let room = beginRoomClose(input.roomId);
-        if (room.state === 'closed')
+        if (room.state === 'closed') {
+            if (!deps.inspectMember)
+                for (const seat of room.member_seats) {
+                    if (existsSync(agentDir(seat.role_name, true)))
+                        throw new Error('Closed room has replacement live state');
+                    await assertMemberIdentityAbsent(seat);
+                }
             return room;
+        }
         try {
             if (room.close?.phase === 'retire_members') {
+                room = await recoverMemberCids(room, input.cowork);
                 for (const seat of room.member_seats) {
                     await retireMember(input.roomId, seat, deps);
                 }
                 room = advanceRoomClose(input.roomId, 'close_cowork');
             }
             if (room.close?.phase === 'close_cowork') {
-                await input.cowork.closeRoom(input.roomId);
+                try {
+                    await input.cowork.closeRoom(input.roomId);
+                }
+                catch (error) {
+                    if (!(error instanceof CoworkProtocolError && error.code === 'not_found'))
+                        throw error;
+                }
             }
             return closeRoom(input.roomId);
         }
@@ -258,7 +310,8 @@ export async function deleteLegacyClosedRooms(input) {
 }
 /** Retire live resources through the existing cursor, then delete retained state. */
 export async function deleteManagedRoom(input) {
-    await closeManagedRoom(input);
+    if (getRoomRecord(input.roomId))
+        await closeManagedRoom(input);
     return withFileLock(roomCloseLockPath(input.roomId), async () => {
         try {
             try {
@@ -276,12 +329,65 @@ export async function deleteManagedRoom(input) {
                 collectWorkspaceArchives(retained.workspace);
                 deleteWorkspace(retained.workspace, 'room', input.roomId);
             }
+            if (retained)
+                await eraseMemberArtifacts('room', input.roomId, retained.member_seats, [input.roomId]);
+            if (retained?.task_id)
+                detachDeletedRoom(retained.task_id, input.roomId);
             deleteRoomRecord(input.roomId);
             return { room_id: input.roomId, deleted: true };
         }
         catch (error) {
-            setRoomCloseError(input.roomId, errorText(error), `Fix the cleanup error and explicitly retry room delete ${input.roomId} ${input.roomId}.`);
+            if (getRoomRecord(input.roomId))
+                setRoomCloseError(input.roomId, errorText(error), `Fix the cleanup error and explicitly retry room delete ${input.roomId} ${input.roomId}.`);
             throw error;
         }
     }, {}, CLOSE_LOCK_STALE_MS);
 }
+/** Recover only an authenticated seat tied to this exact room and issued invite.
+ * Display names and the current daemon name inventory are never binding proof.
+ */
+async function recoverMemberCids(room, cowork) {
+    if (!room.member_seats.some(seat => !seat.identity_cid))
+        return room;
+    const profile = room.member_seats.some(seat => seat.launch?.action_id) ? readClientProfile(process.env) : undefined;
+    let remote;
+    if (cowork.getRoom && room.room_identity_cid) {
+        try {
+            remote = await cowork.getRoom(room.room_id);
+        }
+        catch (error) {
+            if (!(error instanceof CoworkProtocolError && error.code === 'not_found'))
+                throw error;
+        }
+        if (remote && (remote.room_id !== room.room_id || remote.identity_cid.toLowerCase() !== room.room_identity_cid.toLowerCase()))
+            throw new Error('Room identity mismatch during deletion recovery');
+    }
+    const seats = room.member_seats.map(seat => {
+        let runtimeCid;
+        if (profile && seat.launch?.action_id) {
+            const dir = join(stateRoot(), 'private-ours', binderKey(profile.expectedInstanceId, seat.role_name));
+            try {
+                const state = JSON.parse(readFileSync(join(dir, 'state.json'), 'utf8'));
+                const instance = JSON.parse(readFileSync(join(dir, 'instance.json'), 'utf8'));
+                if (state.name === seat.role_name && state.daemon === profile.expectedInstanceId
+                    && state.lifetime === 'temporary' && state.action === seat.launch.action_id
+                    && instance.role === seat.role_name && instance.temporary === true && instance.instance === state.instance)
+                    runtimeCid = state.cid;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        const matches = seat.invite_id ? remote?.seats.filter(value => value.invite_id === seat.invite_id && value.role === seat.cowork_role) ?? [] : [];
+        if (matches.length > 1)
+            throw new Error('Ambiguous authenticated member identity during deletion recovery');
+        const candidates = [seat.identity_cid, runtimeCid, matches[0]?.identity_cid].filter((v) => !!v);
+        if (candidates.some(cid => !/^[a-f0-9]{64}$/i.test(cid)))
+            throw new Error('Invalid authenticated member CID');
+        if (new Set(candidates.map(cid => cid.toLowerCase())).size > 1)
+            throw new Error('Contradictory authenticated member CID evidence');
+        return candidates.length ? { ...seat, identity_cid: candidates[0] } : seat;
+    });
+    return recordRetirementMemberCids(room.room_id, seats);
+}

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. */