@ours.network/fleet 1.1.0-nightly.12 → 1.1.0-nightly.14

package/README.md

@@ -525,6 +525,13 @@ Cowork role, and task. The agent creates that identity itself with ours MCP
 work immediately. Fleet activates the room from Cowork's authenticated seat; there
 is no briefing hash, startup ACK, or separate role-briefing readiness gate.
 
+Set `room.anonymous: true` on a room template, or pass `--anonymous` to
+`task create`, `task start`, `task work`, or `room create`, to create an
+anonymous Cowork room. `--no-anonymous` explicitly overrides an anonymous
+template. Fleet records the resolved value before room creation so retries keep
+the same choice. Temporary members of an anonymous room are instructed to call
+`create_temporary_identity` with `expose_local=false`.
+
 Human task and room results use the same compact Markdown presentation in the
 CLI and authenticated owner channel: a short heading, icon-plus-word status,
 code-formatted identifiers, bounded summaries, and actionable recovery or error

package/dist/application/role-creation-service.js

@@ -10,6 +10,7 @@ import { FleetError, normalizeError } from './errors.js';
 import { inheritCallerSpawnDefaults } from '../fleet-proxy.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { effectiveRoleModel } from '../model-env.js';
+import { selectionOrigin, summarizeResolvedLaunch } from '../lifecycle-summary.js';
 const canonical = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
@@ -71,15 +72,21 @@ export class RoleCreationService {
             const fingerprint = hash(value.inline).slice(0, 16);
             return `inline:sha256:${fingerprint} (${provenance})`;
         };
+        const permissionMode = effectivePermissionMode(plan.preview.resolvedRole);
         return {
             caller: plan.caller, role: plan.options.name,
             lifetime: plan.options.temp ? 'temporary' : 'permanent', statePath,
             harness: plan.preview.resolvedRole.harness, session: plan.preview.resolvedRole.session,
             ...(effectiveRoleModel(plan.preview.resolvedRole) ? { model: effectiveRoleModel(plan.preview.resolvedRole) } : {}),
             monitor: { mode: plan.preview.resolvedRole.monitor.mode, interrupt: plan.preview.resolvedRole.monitor.interrupt },
-            permissionMode: effectivePermissionMode(plan.preview.resolvedRole), inherited: plan.inherited,
+            permissionMode, inherited: plan.inherited,
             creationActionId,
             brainSummary: selectionSummary('brain'), roleSummary: selectionSummary('role'),
+            configuration: summarizeResolvedLaunch(plan.preview.resolvedRole, {
+                role: selectionOrigin(plan.options.role ?? plan.options.agentDefinition?.role),
+                brain: selectionOrigin(plan.options.brain ?? plan.options.agentDefinition?.brain),
+                permissionMode,
+            }),
         };
     }
     launchSync(options, creation) {

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

@@ -3,7 +3,9 @@ import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
 import { provisionMembers } from '../rooms-tasks/provision.js';
 import { moveTaskToList } from '../rooms-tasks/task-state.js';
 import { type MemberOverrides } from '../rooms-tasks/member-overrides.js';
-import type { RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState } from '../rooms-tasks/types.js';
+import { type TaskDeletionSettleResult } from '../rooms-tasks/deletion.js';
+import type { RoomLaunchPolicy, RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState, TemplateSnapshot } from '../rooms-tasks/types.js';
+import type { TaskDeletionAcceptance } from '../rooms-tasks/task-state.js';
 export type TaskRoomActor = {
     kind: 'local_control';
     surface: 'cli' | 'web';
@@ -38,14 +40,17 @@ export interface TaskRecoveryResult {
 export type TaskRecoveryBegin = {
     kind: 'terminal_worker_required';
     taskId: string;
+} | {
+    kind: 'deletion_worker_required';
+    taskId: string;
 } | {
     kind: 'final';
     result: TaskRecoveryResult;
 };
 export declare class TaskRoomApplicationError extends Error {
-    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'room_not_found' | 'room_record_not_found';
+    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found';
     readonly fields: Readonly<Record<string, string>>;
-    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'room_not_found' | 'room_record_not_found', message: string, fields?: Readonly<Record<string, string>>);
+    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found', message: string, fields?: Readonly<Record<string, string>>);
 }
 export interface CreateTaskRequest {
     actor: TaskRoomActor;
@@ -59,6 +64,7 @@ export interface CreateTaskRequest {
     origin: TaskOrigin;
     list?: string;
     members?: MemberOverrides;
+    anonymous?: boolean;
 }
 export interface CreateRoomRequest {
     actor: TaskRoomActor;
@@ -68,13 +74,18 @@ export interface CreateRoomRequest {
     brief?: string;
     briefFile?: string;
     members?: MemberOverrides;
+    anonymous?: boolean;
 }
+export declare function resolveRoomLaunchPolicy(template: TemplateSnapshot | undefined, override: boolean | undefined): RoomLaunchPolicy;
 export interface TaskRoomServiceDeps {
     loadConfiguration?(path?: string): FleetConfig;
     cowork?(config: FleetConfig): CoworkAdapter;
     binPath?(): string;
     provisionMembers?: typeof provisionMembers;
     moveTaskToList?: typeof moveTaskToList;
+    launchDeletionWorker?(taskId: string): Promise<void>;
+    sleep?(ms: number): Promise<void>;
+    now?(): number;
 }
 /** Exact extraction of the previously CLI-owned task create/start behavior. */
 export declare class TaskRoomApplicationService {
@@ -89,15 +100,18 @@ export declare class TaskRoomApplicationService {
         taskId: string;
         template?: string;
         members?: MemberOverrides;
+        anonymous?: boolean;
     }): Promise<TaskRecord>;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
         list?: string;
+        includeDeleting?: boolean;
     }): TaskRecord[];
     listTaskLists(): TaskListRecord[];
     groupedTasks(filter?: {
         state?: TaskState | TaskState[];
         list?: string;
+        includeDeleting?: boolean;
     }): Array<{
         list: TaskListRecord;
         tasks: TaskRecord[];
@@ -142,10 +156,40 @@ export declare class TaskRoomApplicationService {
         actor: TaskRoomActor;
         taskId: string;
     }): TaskRecord;
-    deleteTask(input: {
+    private deletionActor;
+    /** Accept a permanent deletion in any lifecycle state; audit at acceptance. */
+    requestTaskDeletion(input: {
         actor: TaskRoomActor;
         taskId: string;
-    }): boolean;
+    }): Promise<TaskDeletionAcceptance>;
+    /** Worker entry: converge an accepted deletion; Cowork is resolved lazily. */
+    settleTaskDeletion(input: {
+        actor: {
+            kind: 'internal_worker';
+            surface: 'cli';
+        };
+        taskId: string;
+    }): Promise<TaskDeletionSettleResult>;
+    /**
+     * Launch the external deletion worker outside the caller's lifecycle and
+     * wait boundedly for physical absence. Timeouts and launch failures report
+     * a pending, recoverable state — never success. A concurrent worker that
+     * already removed the record reads as settled.
+     */
+    launchTaskDeletionWorker(input: {
+        taskId: string;
+        waitMs?: number;
+    }): Promise<{
+        deleted: boolean;
+        pending: boolean;
+        error?: string;
+    }>;
+    recordDeletionError(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        error: string;
+        recoveryHint: string;
+    }): Promise<TaskRecord>;
     completeTask(input: {
         actor: TaskRoomActor;
         taskId: string;
@@ -202,6 +246,7 @@ export declare class TaskRoomApplicationService {
         identity_cid: string;
         room_name: string;
         state: "provisioning" | "active" | "closing" | "closed";
+        anonymous: boolean;
         seats: import("../rooms-tasks/cowork-adapter.js").CoworkSeatInfo[];
         goal?: string;
         briefing?: string;
@@ -258,6 +303,7 @@ export declare class TaskRoomApplicationService {
         taskId: string;
         template?: string;
         members?: MemberOverrides;
+        anonymous?: boolean;
     }): Promise<{
         task: TaskRecord;
         status: 'ready' | 'already_active';

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

@@ -4,15 +4,18 @@ import { ConfigError, loadConfig } from '../config.js';
 import { CoworkProtocolError, CoworkUnavailableError, createCoworkAdapter, } from '../rooms-tasks/cowork-adapter.js';
 import { getBinPath, provisionMembers } from '../rooms-tasks/provision.js';
 import { activateRoom, advanceSaga, createRoomRecord, getRoomRecord, listRoomRecords, setOwnerSeat, setSagaError, } from '../rooms-tasks/room-state.js';
-import { activateTask, blockTask as persistBlockTask, createTask as persistTask, deleteTask as persistDeleteTask, getTask as readTask, listTasks as readTasks, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, updateTaskExecutionPlan, } from '../rooms-tasks/task-state.js';
+import { activateTask, blockTask as persistBlockTask, createTask as persistTask, getDeletingTask, getTask as readTask, listTasks as readTasks, taskDeletionState, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, updateTaskExecutionPlan, } from '../rooms-tasks/task-state.js';
 import { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked, readTaskLists, renameTaskListLocked, resolveTaskList, TaskListError, withTaskListsLock, } from '../rooms-tasks/task-lists.js';
 import { hashTemplate, listTemplates, resolveTemplate, sealTemplateSnapshot, snapshotTemplate } from '../rooms-tasks/templates.js';
 import { acquireLaunchSnapshotLock, releaseLaunchSnapshot } from '../rooms-tasks/launch-snapshot.js';
 import { hashMemberOverrides, prepareExecutionPlan } from '../rooms-tasks/member-overrides.js';
 import { recordFleetAuditPresentation } from '../fleet-command-audit.js';
 import { acceptManagedRoomClose, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from '../rooms-tasks/close.js';
-import { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from '../rooms-tasks/terminal.js';
-import { TASK_CANCELLABLE_STATES, TASK_TERMINAL_STATES } from '../rooms-tasks/types.js';
+import { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath, } from '../rooms-tasks/terminal.js';
+import { acceptTaskDeletion, recordTaskDeletionError, settleTaskDeletion, } from '../rooms-tasks/deletion.js';
+import { withFileLock } from '../atomic-file.js';
+import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
+import { storedRoomLaunchPolicy, TASK_CANCELLABLE_STATES, TASK_TERMINAL_STATES } from '../rooms-tasks/types.js';
 export class TaskRoomApplicationError extends Error {
     code;
     fields;
@@ -23,6 +26,10 @@ export class TaskRoomApplicationError extends Error {
         this.name = 'TaskRoomApplicationError';
     }
 }
+export function resolveRoomLaunchPolicy(template, override) {
+    const anonymous = override ?? template?.room?.anonymous ?? false;
+    return { anonymous };
+}
 function launchSelection(definition, key) {
     const selected = definition?.[key];
     if (!selected || typeof selected !== 'object' || Array.isArray(selected))
@@ -48,6 +55,7 @@ function roomParticipants(room) {
         brain: launchSelection(seat.launch?.agent_definition, 'brain'),
         role: launchSelection(seat.launch?.agent_definition, 'role') ?? seat.cowork_role,
         permissions: launchPermissions(seat.launch?.agent_definition),
+        ...(seat.launch?.presentation ? { configuration: seat.launch.presentation } : {}),
     }));
 }
 function taskAgents(task) {
@@ -57,7 +65,8 @@ function taskAgents(task) {
         const seat = seats.get(member.name);
         return { name: member.name, brain: launchSelection(seat?.launch?.agent_definition, 'brain'),
             role: launchSelection(seat?.launch?.agent_definition, 'role') ?? member.cowork_role,
-            permissions: launchPermissions(seat?.launch?.agent_definition) };
+            permissions: launchPermissions(seat?.launch?.agent_definition),
+            ...(seat?.launch?.presentation ? { configuration: seat.launch.presentation } : {}) };
     });
 }
 function roomFailureEventId(room) {
@@ -76,6 +85,9 @@ export class TaskRoomApplicationService {
     async createTask(request) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let template = this.createTemplate(cfg, request.template, request.noRoom);
+        if (request.noRoom && request.anonymous !== undefined)
+            throw new ConfigError('--anonymous/--no-anonymous cannot be combined with --no-room');
+        const roomPolicy = resolveRoomLaunchPolicy(template, request.anonymous);
         let launchDefinitions;
         let executionPlan;
         let preparedPlan;
@@ -92,7 +104,8 @@ export class TaskRoomApplicationService {
             if (preparedPlan) {
                 template = sealTemplateSnapshot(preparedPlan.snapshot, cfg.agentTemplates ?? {}, preparedPlan.launchDefinitions);
                 sealedHash = template.launch_snapshot_hash;
-                executionPlan = { schema_version: 1, snapshot: template, overrides: preparedPlan.overrides,
+                executionPlan = { schema_version: 1, snapshot: template, room_policy: roomPolicy,
+                    overrides: preparedPlan.overrides,
                     overrides_hash: preparedPlan.overridesHash,
                     plan_hash: preparedPlan.planHash };
             }
@@ -124,7 +137,7 @@ export class TaskRoomApplicationService {
             try {
                 const room = await this.provisionRoom(cfg, task, template, created => {
                     task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
-                }, launchDefinitions);
+                }, launchDefinitions, roomPolicy);
                 task = readTask(task.task_id);
                 if (task.state === 'active' && room.state === 'active')
                     recordFleetAuditPresentation({ kind: 'task', operation: 'work', id: task.task_id,
@@ -159,20 +172,22 @@ export class TaskRoomApplicationService {
             if (request.members && Object.keys(request.members).length) {
                 const prepared = prepareExecutionPlan(definition, cfg, request.members);
                 template = prepared.snapshot;
-                return this.provisionRoom(cfg, { title: request.name, brief, goal: request.goal }, template, () => { }, prepared.launchDefinitions);
+                const roomPolicy = resolveRoomLaunchPolicy(template, request.anonymous);
+                return this.provisionRoom(cfg, { title: request.name, brief, goal: request.goal }, template, () => { }, prepared.launchDefinitions, roomPolicy);
             }
             template = snapshotTemplate(definition, cfg.agentTemplates);
         }
+        const roomPolicy = resolveRoomLaunchPolicy(template, request.anonymous);
         return this.provisionRoom(cfg, {
             title: request.name, brief, goal: request.goal,
-        }, template, () => { });
+        }, template, () => { }, undefined, roomPolicy);
     }
     async startTask(input) {
         return (await this.ensureTaskWork(input)).task;
     }
     listTasks(filter) {
         const listId = filter?.list === undefined ? undefined : resolveTaskList(filter.list).list_id;
-        return readTasks({ state: filter?.state, listId });
+        return readTasks({ state: filter?.state, listId, includeDeleting: filter?.includeDeleting });
     }
     listTaskLists() { return readTaskLists(); }
     groupedTasks(filter) {
@@ -225,8 +240,93 @@ export class TaskRoomApplicationService {
     reviewTask(input) {
         return persistReviewTask(input.taskId);
     }
-    deleteTask(input) {
-        return persistDeleteTask(input.taskId);
+    deletionActor(actor) {
+        if (actor.kind === 'local_control')
+            return { kind: 'local_control', surface: actor.surface };
+        if (actor.kind === 'authenticated_owner')
+            return { kind: 'authenticated_owner', surface: 'messenger', cid: actor.cid };
+        throw new Error('internal workers cannot originate a task deletion acceptance');
+    }
+    /** Accept a permanent deletion in any lifecycle state; audit at acceptance. */
+    async requestTaskDeletion(input) {
+        const result = await acceptTaskDeletion(input.taskId, this.deletionActor(input.actor));
+        if (result.status === 'accepted') {
+            const task = result.task;
+            recordFleetAuditPresentation({ kind: 'task', operation: 'delete', id: task.task_id,
+                title: task.title, previousState: task.state, newState: 'deleting',
+                revision: task.deletion?.accepted_at ?? task.created_at, list: task.list_name ?? 'default',
+                roomId: task.room_id,
+                template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+                agents: [] });
+        }
+        return result;
+    }
+    /** Worker entry: converge an accepted deletion; Cowork is resolved lazily. */
+    async settleTaskDeletion(input) {
+        const result = await settleTaskDeletion({
+            taskId: input.taskId,
+            cowork: () => {
+                // Config resolves only when room work exists: a no-room deletion must
+                // settle even with missing or invalid rooms configuration.
+                const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+                if (!cfg.rooms)
+                    throw new ConfigError('rooms: configuration is required before deleting task rooms');
+                return this.deps.cowork ? this.deps.cowork(cfg)
+                    : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+            },
+        });
+        if (result.deleted && result.previous_state) {
+            recordFleetAuditPresentation({ kind: 'task', operation: 'delete', id: result.task_id,
+                title: result.title, previousState: result.previous_state, newState: 'deleted',
+                revision: new Date().toISOString(), list: 'default', roomId: undefined,
+                template: undefined, agents: [] });
+        }
+        return result;
+    }
+    /**
+     * Launch the external deletion worker outside the caller's lifecycle and
+     * wait boundedly for physical absence. Timeouts and launch failures report
+     * a pending, recoverable state — never success. A concurrent worker that
+     * already removed the record reads as settled.
+     */
+    async launchTaskDeletionWorker(input) {
+        const launch = this.deps.launchDeletionWorker
+            ?? ((taskId) => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, this.configurationPath));
+        const errorAtBefore = (() => {
+            try {
+                return getDeletingTask(input.taskId).deletion?.error_at;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        try {
+            await launch(input.taskId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await recordTaskDeletionError(input.taskId, message, `External delete worker failed to start. Repeat the delete request for ${input.taskId}.`).catch(() => { });
+            return { deleted: false, pending: true, error: message };
+        }
+        const now = this.deps.now ?? Date.now;
+        const sleep = this.deps.sleep
+            ?? ((ms) => new Promise(resolve => { setTimeout(resolve, ms); }));
+        const deadline = now() + (input.waitMs ?? 10_000);
+        while (now() < deadline) {
+            if (taskDeletionState(input.taskId) === 'absent')
+                return { deleted: true, pending: false };
+            try {
+                const current = getDeletingTask(input.taskId).deletion;
+                if (current?.error_at !== errorAtBefore && current?.error)
+                    return { deleted: false, pending: true, error: current.error };
+            }
+            catch { /* re-checked as absence on the next iteration */ }
+            await sleep(100);
+        }
+        return { deleted: false, pending: true };
+    }
+    recordDeletionError(input) {
+        return recordTaskDeletionError(input.taskId, input.error, input.recoveryHint);
     }
     async completeTask(input) {
         const task = readTask(input.taskId);
@@ -265,10 +365,22 @@ export class TaskRoomApplicationService {
         return recordTaskTerminalIntentError(input.taskId, input.error, input.recoveryHint);
     }
     async beginTaskRecovery(input) {
+        // The deletion-vs-terminal routing decision serializes on the common
+        // task-operation lock and must not require configuration: recovery of a
+        // deletion-pending task continues the deletion and never resurrects.
+        const routed = await withFileLock(taskOperationLockPath(input.taskId), () => {
+            const task = readTask(input.taskId);
+            if (task.deletion?.status === 'pending')
+                return 'deletion';
+            if (task.terminal_intent?.status === 'pending')
+                return 'terminal';
+            return 'none';
+        }, {}, TASK_OPERATION_LOCK_STALE_MS);
+        if (routed === 'deletion')
+            return { kind: 'deletion_worker_required', taskId: input.taskId };
         const config = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         this.recovery = { taskId: input.taskId, config };
-        const task = readTask(input.taskId);
-        if (task.terminal_intent?.status === 'pending')
+        if (routed === 'terminal')
             return { kind: 'terminal_worker_required', taskId: input.taskId };
         return { kind: 'final', result: await this.continueTaskRecovery({
                 actor: input.actor, taskId: input.taskId, terminalTimedOut: false,
@@ -430,6 +542,14 @@ export class TaskRoomApplicationService {
             return { kind: 'deletion_worker_required', roomId: input.roomId };
         const room = await adapter.recoverRoom(input.roomId);
         orchestration = getRoomRecord(input.roomId);
+        if (orchestration) {
+            const policy = storedRoomLaunchPolicy(orchestration.room_policy);
+            if ((room.anonymous ?? false) !== policy.anonymous) {
+                const error = `Cowork anonymity (${String(room.anonymous ?? false)}) does not match Fleet's durable Room policy (${String(policy.anonymous)})`;
+                setSagaError(input.roomId, error, 'Do not respawn members. Repair or upgrade Cowork, then recover the Room without changing its policy.', 'waiting_cowork');
+                throw new Error(error);
+            }
+        }
         if (orchestration && !orchestration.owner_seat_cid
             && (orchestration.provisioning_detail === 'waiting_owner_invite'
                 || orchestration.provisioning_detail === 'owner_cid_mismatch')) {
@@ -499,6 +619,10 @@ export class TaskRoomApplicationService {
     async ensureTaskWork(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let task = readTask(input.taskId);
+        const recordedRoom = task.room_id ? getRoomRecord(task.room_id) : undefined;
+        const recordedPolicy = storedRoomLaunchPolicy(recordedRoom?.room_policy ?? task.execution_plan?.room_policy);
+        if (task.room_id && input.anonymous !== undefined && input.anonymous !== recordedPolicy.anonymous)
+            throw new TaskRoomApplicationError('template_mismatch', 'anonymous override does not match the existing Room launch policy', { room: task.room_id });
         if (TASK_TERMINAL_STATES.includes(task.state))
             throw new TaskRoomApplicationError('task_terminal', 'task terminal', { task: input.taskId, state: task.state });
         if (task.state === 'active' && task.room_id) {
@@ -542,6 +666,11 @@ export class TaskRoomApplicationService {
         let preparedPlan = !durable && definition
             ? prepareExecutionPlan(definition, cfg, input.members ?? {}) : undefined;
         let snapshot = durable ?? preparedPlan.snapshot;
+        const roomPolicy = input.anonymous !== undefined
+            ? resolveRoomLaunchPolicy(snapshot, input.anonymous)
+            : task.execution_plan
+                ? storedRoomLaunchPolicy(task.execution_plan.room_policy)
+                : resolveRoomLaunchPolicy(snapshot, undefined);
         if (preparedPlan)
             launchDefinitions = preparedPlan.launchDefinitions;
         if (input.members && Object.keys(input.members).length && !storedOverridesMatch) {
@@ -584,6 +713,7 @@ export class TaskRoomApplicationService {
             try {
                 sealed = sealTemplateSnapshot(snapshot, cfg.agentTemplates ?? {}, launchDefinitions);
                 task = updateTaskExecutionPlan(task.task_id, { schema_version: 1, snapshot: sealed,
+                    room_policy: roomPolicy,
                     overrides: preparedPlan.overrides, overrides_hash: preparedPlan.overridesHash,
                     plan_hash: preparedPlan.planHash });
                 snapshot = sealed;
@@ -596,6 +726,9 @@ export class TaskRoomApplicationService {
             }
             unlock();
         }
+        else if (!task.room_id && task.execution_plan && input.anonymous !== undefined) {
+            task = updateTaskExecutionPlan(task.task_id, { ...task.execution_plan, room_policy: roomPolicy });
+        }
         else if (!task.template || task.template.name !== snapshot.name || task.template.content_hash !== snapshot.content_hash)
             task = updateTaskTemplate(task.task_id, { name: snapshot.name, version: snapshot.version, content_hash: snapshot.content_hash });
         if (task.state === 'backlog') {
@@ -609,7 +742,7 @@ export class TaskRoomApplicationService {
             try {
                 await this.provisionRoom(cfg, task, snapshot, created => {
                     task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
-                }, launchDefinitions);
+                }, launchDefinitions, roomPolicy);
                 task = readTask(task.task_id);
             }
             catch (error) {
@@ -676,7 +809,7 @@ export class TaskRoomApplicationService {
             throw new TaskRoomApplicationError('task_template_drift', `task template snapshot no longer matches ${ref.name}@${ref.version}`);
         return snapshot;
     }
-    async provisionRoom(cfg, task, template, onCreated, launchDefinitions) {
+    async provisionRoom(cfg, task, template, onCreated, launchDefinitions, policy = resolveRoomLaunchPolicy(template, undefined)) {
         const rooms = cfg.rooms;
         if (!rooms)
             throw new ConfigError('rooms: configuration is required');
@@ -690,21 +823,37 @@ export class TaskRoomApplicationService {
         })();
         const unlockSnapshot = template ? acquireLaunchSnapshotLock() : undefined;
         let launchTemplate;
-        let created;
         let room;
         try {
             launchTemplate = template ? (template.launch_snapshot_hash ? template
                 : sealTemplateSnapshot(template, cfg.agentTemplates ?? {}, launchDefinitions)) : undefined;
-            created = await cowork.createRoom({
-                room_name: task.title, goal: task.goal?.trim() || task.title,
-                briefing: task.brief?.trim() || launchTemplate?.contract?.trim() || task.goal?.trim() || task.title,
-                quiet_membership: launchTemplate?.room?.quiet_membership,
-                anonymous: launchTemplate?.room?.anonymous,
-            });
-            room = createRoomRecord({
-                room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
-                task_id: task.task_id, template_snapshot: launchTemplate,
-            });
+            // Room publication window: for a task-bound room, hold the common
+            // task-operation lock across remote creation, local record creation, and
+            // the task link, so an accepted deletion linearizes strictly before
+            // (bounded task_deleting abort) or strictly after (record visible to the
+            // deletion scan). Lock order stays launch-snapshot → task-operation.
+            const publishRoom = async () => {
+                if (task.task_id) {
+                    const fresh = readTask(task.task_id);
+                    if (fresh.deletion?.status === 'pending')
+                        throw new TaskRoomApplicationError('task_deleting', `task ${task.task_id} is pending deletion`, { task: task.task_id });
+                }
+                const created = await cowork.createRoom({
+                    room_name: task.title, goal: task.goal?.trim() || task.title,
+                    briefing: task.brief?.trim() || launchTemplate?.contract?.trim() || task.goal?.trim() || task.title,
+                    quiet_membership: launchTemplate?.room?.quiet_membership,
+                    anonymous: policy.anonymous,
+                });
+                const record = createRoomRecord({
+                    room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
+                    task_id: task.task_id, template_snapshot: launchTemplate, room_policy: policy,
+                });
+                onCreated(record);
+                return record;
+            };
+            room = task.task_id
+                ? await withFileLock(taskOperationLockPath(task.task_id), publishRoom, {}, TASK_OPERATION_LOCK_STALE_MS)
+                : await publishRoom();
         }
         catch (error) {
             unlockSnapshot?.();
@@ -718,7 +867,6 @@ export class TaskRoomApplicationService {
             revision: room.created_at, taskId: room.task_id,
             template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
             participants: [] });
-        onCreated(room);
         room = advanceSaga(room.room_id, 'create_room', 1);
         if (attachOwner) {
             try {

package/dist/briefing.js

@@ -1,9 +1,9 @@
 import { userInfo } from 'node:os';
 import { oversightTaxonomyLines } from './session/control.js';
-function temporaryIdentityBootstrap(id, v) {
+function temporaryIdentityBootstrap(id, v, anonymous = false) {
     return [
         `2. CREATE your ours identity now: call **${v.temporaryCreateTool}** through ours MCP`,
-        `   with the exact assigned name "${id}". The ours connector owns its cleanup when this`,
+        `   with the exact assigned name "${id}"${anonymous ? ' and expose_local=false' : ''}. The ours connector owns its cleanup when this`,
         '   connector session lifecycle ends.',
         '   Do not inspect, preserve, adopt, or use any pre-existing or persistent identity.',
         '   On a collision, missing tool, or creation error, STOP and',
@@ -24,7 +24,7 @@ function generateRoomMemberBriefing(role, v, opts, prefix) {
     L.push('', '### One-time room invite', '', '```text', startup.invite, '```');
     L.push('', '## Do these NOW, in order');
     L.push(`1. ${v.launchNote(role.name)}`);
-    L.push(...temporaryIdentityBootstrap(startup.identity_name, v));
+    L.push(...temporaryIdentityBootstrap(startup.identity_name, v, startup.anonymous));
     L.push('3. Call **add_contact** through ours MCP with the exact one-time invite above. Confirm');
     L.push(`   that it resolves to room CID \`${startup.room_identity_cid}\`. The contact may remain`);
     L.push('   pending while the room finishes its asynchronous verification.');

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.12",
-  "buildId": "6da038d91a6d",
-  "commit": "57faa7ff79b4097ac94797b9a591ce54aad01c0a",
+  "version": "1.1.0-nightly.14",
+  "buildId": "3651cb00af5a",
+  "commit": "974e9150cbb9d24f92412866de7a53a0cd6fde8f",
   "dirty": true,
-  "builtAt": "2026-08-31T21:40:11.904Z",
+  "builtAt": "2026-09-01T08:58:08.364Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/config.d.ts

@@ -175,6 +175,7 @@ export interface RoomMemberStartup {
     role: string;
     task: string;
     owner_seat_cid: string | null;
+    anonymous?: boolean;
 }
 export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel' | 'worklog'> {
     name: string;