@ours.network/fleet 1.1.0-nightly.13 → 1.1.0-nightly.15

package/dist/harness/codex-app-server-proxy.js

@@ -9,9 +9,281 @@ const SANDBOX_ENV = 'OURS_FLEET_CODEX_SANDBOX';
 const REAL_CODEX_ENV = 'OURS_FLEET_REAL_CODEX_PATH';
 const ACP_MANIFEST_ENV = 'OURS_FLEET_CODEX_ACP_MANIFEST';
 const DISABLE_INHERITED_MCP_ENV = 'OURS_FLEET_CODEX_DISABLE_INHERITED_MCP';
+/**
+ * Codex 0.145 can finish a tool-enabled turn without emitting the documented
+ * `turn/completed` notification. Keep this short: the authoritative
+ * `thread/read` reconciliation below, rather than elapsed time, is what makes
+ * inference safe.
+ */
+const TERMINAL_RECONCILE_QUIET_MS = 2_000;
+const MAX_LATE_TERMINAL_DEDUPLICATIONS = 1_024;
 const APPROVAL_POLICIES = new Set(['untrusted', 'on-request', 'never']);
 const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
 const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const jsonRpcId = (value) => typeof value === 'string' || typeof value === 'number' ? value : undefined;
+const stringField = (value, field) => isObject(value) && typeof value[field] === 'string' ? value[field] : undefined;
+const turnKey = (threadId, turnId) => `${threadId}\0${turnId}`;
+/**
+ * Reconcile Codex's missing terminal notification without guessing from a
+ * wall-clock timeout. A candidate needs the exact turn's authoritative final
+ * assistant item, no live items or server requests, and a quiet period. The
+ * proxy then asks app-server for the current thread snapshot. Only a terminal
+ * stored turn, or an idle thread containing that exact turn, may synthesize the
+ * missing notification.
+ *
+ * This lives in the authenticated bundled-Codex proxy, not the generic ACP
+ * session: only here are App Server thread/turn IDs and item lifecycles visible.
+ */
+export class CodexTerminalRecovery {
+    options;
+    turns = new Map();
+    pendingTurnStarts = new Map();
+    serverRequests = new Map();
+    reconcileRequests = new Map();
+    inferredTurns = new Set();
+    reconcileSequence = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    observeClientLine(line) {
+        const message = this.parse(line);
+        if (!message)
+            return;
+        const id = jsonRpcId(message.id);
+        if (message.method === 'turn/start' && id !== undefined) {
+            const threadId = stringField(message.params, 'threadId');
+            if (threadId)
+                this.pendingTurnStarts.set(id, threadId);
+            return;
+        }
+        if (id === undefined || message.method !== undefined)
+            return;
+        const key = this.serverRequests.get(id);
+        if (!key)
+            return;
+        this.serverRequests.delete(id);
+        const turn = this.turns.get(key);
+        turn?.openServerRequests.delete(id);
+        if (turn)
+            this.scheduleReconciliation(turn);
+    }
+    /** Return false when an internal response or late duplicate was consumed. */
+    observeServerLine(line) {
+        const message = this.parse(line);
+        if (!message)
+            return true;
+        const id = jsonRpcId(message.id);
+        if (id !== undefined && message.method === undefined) {
+            const reconcileKey = this.reconcileRequests.get(id);
+            if (reconcileKey) {
+                this.reconcileRequests.delete(id);
+                this.handleReconcileResponse(reconcileKey, message);
+                return false;
+            }
+            const threadId = this.pendingTurnStarts.get(id);
+            if (threadId) {
+                this.pendingTurnStarts.delete(id);
+                const turn = isObject(message.result) && isObject(message.result.turn)
+                    ? message.result.turn : undefined;
+                const turnId = stringField(turn, 'id');
+                if (turn && turnId)
+                    this.ensureTurn(threadId, turnId, turn);
+            }
+            return true;
+        }
+        if (message.method === 'turn/started') {
+            const threadId = stringField(message.params, 'threadId');
+            const turn = isObject(message.params) && isObject(message.params.turn)
+                ? message.params.turn : undefined;
+            const turnId = stringField(turn, 'id');
+            if (threadId && turn && turnId)
+                this.ensureTurn(threadId, turnId, turn);
+            return true;
+        }
+        if (message.method === 'turn/completed') {
+            const threadId = stringField(message.params, 'threadId');
+            const turn = isObject(message.params) && isObject(message.params.turn)
+                ? message.params.turn : undefined;
+            const turnId = stringField(turn, 'id');
+            if (!threadId || !turnId)
+                return true;
+            const key = turnKey(threadId, turnId);
+            if (this.inferredTurns.delete(key)) {
+                this.options.log(`suppressed late turn/completed after inferred terminal (${threadId}/${turnId})`);
+                return false;
+            }
+            this.finishTurn(key);
+            return true;
+        }
+        if (message.method === 'thread/status/changed') {
+            const threadId = stringField(message.params, 'threadId');
+            const status = isObject(message.params) && isObject(message.params.status)
+                ? message.params.status : undefined;
+            if (threadId && status?.type === 'idle') {
+                for (const turn of this.turns.values()) {
+                    if (turn.threadId !== threadId)
+                        continue;
+                    turn.idleObserved = true;
+                    this.scheduleReconciliation(turn);
+                }
+            }
+            return true;
+        }
+        const params = isObject(message.params) ? message.params : undefined;
+        const threadId = stringField(params, 'threadId');
+        const routedTurnId = stringField(params, 'turnId');
+        const routed = threadId && routedTurnId
+            ? this.turns.get(turnKey(threadId, routedTurnId)) : undefined;
+        if (routed && message.method === 'item/started') {
+            const item = isObject(params?.item) ? params.item : undefined;
+            const itemId = stringField(item, 'id');
+            if (itemId)
+                routed.openItems.add(itemId);
+            // Work after a final answer invalidates that candidate. A later exact
+            // final answer can establish a new one.
+            if (item?.type !== 'agentMessage' || item?.phase !== 'final_answer')
+                routed.finalAssistantItem = undefined;
+            this.cancelReconciliation(routed);
+        }
+        else if (routed && message.method === 'item/completed') {
+            const item = isObject(params?.item) ? params.item : undefined;
+            const itemId = stringField(item, 'id');
+            if (itemId)
+                routed.openItems.delete(itemId);
+            if (item?.type === 'agentMessage' && item.phase === 'final_answer'
+                && typeof item.text === 'string' && item.text.length > 0)
+                routed.finalAssistantItem = item;
+            this.scheduleReconciliation(routed);
+        }
+        // App-server requests (approvals, elicitation, user input) are obligations
+        // the client still owes. Never infer while one for this turn is unresolved.
+        if (routed && id !== undefined && typeof message.method === 'string') {
+            this.serverRequests.set(id, turnKey(routed.threadId, routed.turnId));
+            routed.openServerRequests.add(id);
+            this.cancelReconciliation(routed);
+        }
+        return true;
+    }
+    close() {
+        for (const turn of this.turns.values())
+            this.cancelReconciliation(turn);
+        this.turns.clear();
+        this.pendingTurnStarts.clear();
+        this.serverRequests.clear();
+        this.reconcileRequests.clear();
+        this.inferredTurns.clear();
+    }
+    parse(line) {
+        try {
+            const parsed = JSON.parse(line);
+            return isObject(parsed) ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    ensureTurn(threadId, turnId, turn) {
+        const key = turnKey(threadId, turnId);
+        const existing = this.turns.get(key);
+        if (existing) {
+            existing.turn = turn;
+            return existing;
+        }
+        const created = {
+            threadId, turnId, turn, openItems: new Set(), openServerRequests: new Set(),
+            idleObserved: false,
+        };
+        this.turns.set(key, created);
+        return created;
+    }
+    candidate(turn) {
+        return turn.finalAssistantItem !== undefined
+            && turn.openItems.size === 0 && turn.openServerRequests.size === 0
+            && turn.reconcileRequestId === undefined;
+    }
+    cancelReconciliation(turn) {
+        if (turn.reconcileTimer)
+            clearTimeout(turn.reconcileTimer);
+        turn.reconcileTimer = undefined;
+    }
+    scheduleReconciliation(turn) {
+        this.cancelReconciliation(turn);
+        if (!this.candidate(turn))
+            return;
+        turn.reconcileTimer = setTimeout(() => this.reconcile(turn), this.options.quietMs ?? TERMINAL_RECONCILE_QUIET_MS);
+        turn.reconcileTimer.unref?.();
+    }
+    reconcile(turn) {
+        turn.reconcileTimer = undefined;
+        if (!this.candidate(turn))
+            return;
+        const id = `ours-fleet-terminal-reconcile-${++this.reconcileSequence}`;
+        const key = turnKey(turn.threadId, turn.turnId);
+        turn.reconcileRequestId = id;
+        this.reconcileRequests.set(id, key);
+        this.options.sendToCodex(JSON.stringify({
+            id, method: 'thread/read', params: { threadId: turn.threadId, includeTurns: true },
+        }));
+    }
+    handleReconcileResponse(key, message) {
+        const tracked = this.turns.get(key);
+        if (!tracked)
+            return;
+        tracked.reconcileRequestId = undefined;
+        if (!this.candidate(tracked))
+            return;
+        const thread = isObject(message.result) && isObject(message.result.thread)
+            ? message.result.thread : undefined;
+        const turns = thread && Array.isArray(thread.turns) ? thread.turns : [];
+        const snapshot = turns.find(candidate => isObject(candidate) && candidate.id === tracked.turnId);
+        if (!snapshot) {
+            this.scheduleReconciliation(tracked);
+            return;
+        }
+        const status = typeof snapshot.status === 'string' ? snapshot.status : undefined;
+        const threadStatus = thread && isObject(thread.status) ? thread.status.type : undefined;
+        const storedTerminal = status === 'completed' || status === 'failed' || status === 'interrupted';
+        if (!storedTerminal && threadStatus !== 'idle' && !tracked.idleObserved) {
+            // A final answer can precede stop hooks or other short-lived runtime
+            // effects. Keep reconciling while the exact thread still reports active;
+            // never convert elapsed time alone into success.
+            this.scheduleReconciliation(tracked);
+            return;
+        }
+        const inferredTurn = storedTerminal ? snapshot : {
+            ...snapshot,
+            status: 'completed',
+            error: null,
+            completedAt: snapshot.completedAt ?? new Date().toISOString(),
+        };
+        this.inferredTurns.add(key);
+        if (this.inferredTurns.size > MAX_LATE_TERMINAL_DEDUPLICATIONS) {
+            const oldest = this.inferredTurns.values().next().value;
+            if (oldest)
+                this.inferredTurns.delete(oldest);
+        }
+        this.options.log(`inferred missing turn/completed after authoritative reconciliation (${tracked.threadId}/${tracked.turnId})`);
+        this.options.emitToClient(JSON.stringify({
+            method: 'turn/completed',
+            params: { threadId: tracked.threadId, turn: inferredTurn },
+            _meta: { oursFleet: { terminalSource: 'inferred_missing_notification' } },
+        }));
+        this.finishTurn(key);
+    }
+    finishTurn(key) {
+        const turn = this.turns.get(key);
+        if (!turn)
+            return;
+        this.cancelReconciliation(turn);
+        if (turn.reconcileRequestId !== undefined) {
+            this.reconcileRequests.delete(turn.reconcileRequestId);
+            turn.reconcileRequestId = undefined;
+        }
+        for (const id of turn.openServerRequests)
+            this.serverRequests.delete(id);
+        this.turns.delete(key);
+    }
+}
 function sandboxMode(policy) {
     if (!isObject(policy))
         return undefined;
@@ -94,24 +366,83 @@ export function runCodexAppServerProxy() {
     const child = spawn(launch.command, launch.args, {
         env, shell: launch.shell, stdio: ['pipe', 'pipe', 'pipe'],
     });
-    child.stdout.pipe(process.stdout);
-    child.stderr.pipe(process.stderr);
+    child.stderr.pipe(process.stderr, { end: false });
     const input = createInterface({ input: process.stdin });
+    const output = createInterface({ input: child.stdout });
     let finished = false;
+    let clientBackpressured = false;
+    const writeToClient = (line) => {
+        if (finished)
+            return;
+        if (!process.stdout.write(line + '\n')) {
+            if (!clientBackpressured) {
+                clientBackpressured = true;
+                output.pause();
+                process.stdout.once('drain', () => {
+                    clientBackpressured = false;
+                    if (!finished)
+                        output.resume();
+                });
+            }
+        }
+    };
+    let childBackpressured = false;
+    const pendingChildLines = [];
+    const writeToChild = (line) => {
+        if (finished || child.stdin.destroyed)
+            return;
+        if (childBackpressured) {
+            pendingChildLines.push(line);
+            return;
+        }
+        if (!child.stdin.write(line + '\n')) {
+            childBackpressured = true;
+            input.pause();
+            child.stdin.once('drain', () => {
+                childBackpressured = false;
+                while (!childBackpressured && pendingChildLines.length > 0) {
+                    const pending = pendingChildLines.shift();
+                    if (!child.stdin.write(pending + '\n'))
+                        childBackpressured = true;
+                }
+                if (!finished && !childBackpressured)
+                    input.resume();
+            });
+        }
+    };
+    const recovery = new CodexTerminalRecovery({
+        sendToCodex: writeToChild,
+        emitToClient: writeToClient,
+        log: line => process.stderr.write(`ours-fleet Codex terminal recovery: ${line}\n`),
+    });
     const finish = (code) => {
         if (finished)
             return;
         finished = true;
-        process.exitCode = code;
+        recovery.close();
         input.close();
         process.stdin.destroy();
+        // stdout/stderr are often pipes under Fleet and tests. Setting exitCode
+        // before their pending writes flush can drop the child's last diagnostic
+        // or protocol line. Empty writes provide ordered flush barriers.
+        // Let readable `data`/`line` callbacks queued with the child's `close`
+        // notification run before placing the barriers.
+        setImmediate(() => {
+            process.stdout.write('', () => {
+                process.stderr.write('', () => { process.exitCode = code; });
+            });
+        });
     };
+    let spawnFailed = false;
     child.once('error', error => {
+        spawnFailed = true;
         process.stderr.write(`ours-fleet Codex app-server proxy: ${error.message}\n`);
-        finish(1);
     });
-    child.once('exit', (code, signal) => {
-        finish(code ?? (signal ? 1 : 0));
+    // `exit` can precede the final stdout/stderr chunks. Wait for `close`, which
+    // is emitted only after the child's stdio streams have closed, so a fast
+    // failure cannot lose its diagnostic or the last protocol envelope.
+    child.once('close', (code, signal) => {
+        finish(spawnFailed ? 1 : code ?? (signal ? 1 : 0));
     });
     // A child can close its input before Node delivers its exit event. Its exit
     // status is the authoritative failure; do not let the resulting EPIPE race it.
@@ -119,19 +450,22 @@ export function runCodexAppServerProxy() {
     input.on('line', line => {
         if (finished)
             return;
-        const output = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp) + '\n';
-        if (!child.stdin.write(output)) {
-            input.pause();
-            child.stdin.once('drain', () => {
-                if (!finished)
-                    input.resume();
-            });
-        }
+        const rewritten = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp);
+        recovery.observeClientLine(rewritten);
+        writeToChild(rewritten);
+    });
+    output.on('line', line => {
+        if (!finished && recovery.observeServerLine(line))
+            writeToClient(line);
     });
     input.once('close', () => {
         if (!child.stdin.destroyed)
             child.stdin.end();
     });
+    process.stdin.once('end', () => {
+        if (!child.stdin.destroyed)
+            child.stdin.end();
+    });
     for (const signal of ['SIGINT', 'SIGTERM'])
         process.once(signal, () => child.kill(signal));
 }

package/dist/rooms-tasks/cli.js

@@ -29,6 +29,13 @@ function commandArgv(command) {
         root = root.parent;
     return root.rawArgs ?? process.argv.slice(2);
 }
+function cliAnonymousOverride(argv) {
+    const enabled = argv.includes('--anonymous');
+    const disabled = argv.includes('--no-anonymous');
+    if (enabled && disabled)
+        throw new Error('--anonymous and --no-anonymous are mutually exclusive');
+    return enabled ? true : disabled ? false : undefined;
+}
 import { getTask, getDeletingTask, activateTask, TaskStateError, } from './task-state.js';
 import { createRoomRecord, getRoomRecord, advanceSaga, setOwnerSeat, setSagaError, activateRoom, RoomStateError, } from './room-state.js';
 import { createCoworkAdapter, CoworkProtocolError } from './cowork-adapter.js';
@@ -690,6 +697,8 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--brief-file <path>', 'task brief from file')
         .option('--backlog', 'create in backlog (do not start immediately)')
         .option('--no-room', 'create task without a room')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
         .option('--idempotency-key <key>', 'idempotency key')
         .option('--list <name>', 'task list (default: default)')
         .option('--members-file <path>', 'typed YAML member overrides')
@@ -711,6 +720,7 @@ export function registerTaskCommands(parent, cOpt) {
                 actor: { kind: 'local_control', surface: 'cli' }, title: opts.title,
                 brief: opts.brief, briefFile: opts.briefFile, template: opts.template,
                 backlog: opts.backlog, noRoom: opts.room === false,
+                anonymous: cliAnonymousOverride(commandArgv(command)),
                 idempotencyKey: opts.idempotencyKey, origin: { type: 'cli' },
                 list: opts.list,
                 members,
@@ -903,6 +913,8 @@ export function registerTaskCommands(parent, cOpt) {
     cOpt(taskCmd.command('start <id>'))
         .description('idempotently select a plan, provision, and start a task')
         .option('--template <name>', 'room template')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
         .option('--members-file <path>', 'typed YAML member overrides')
         .option('--member <slot>', 'begin a typed member override block')
         .option('--agent-template <id>', 'Agent Template for current member')
@@ -920,6 +932,7 @@ export function registerTaskCommands(parent, cOpt) {
             const t = await taskRoomService(opts.configuration).startTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
                 template: opts.template, members: cliMemberOverrides(opts.membersFile, commandArgv(command)),
+                anonymous: cliAnonymousOverride(commandArgv(command)),
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
@@ -1310,6 +1323,8 @@ export function registerTaskCommands(parent, cOpt) {
     cOpt(taskCmd.command('work <id>'))
         .description('deprecated alias for task start')
         .option('--template <name>', 'room template')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
         .option('--members-file <path>', 'typed YAML member overrides')
         .option('--member <slot>', 'begin a typed member override block')
         .option('--agent-template <id>', 'Agent Template for current member')
@@ -1329,6 +1344,7 @@ export function registerTaskCommands(parent, cOpt) {
             const result = await taskRoomService(opts.configuration).ensureTaskWork({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, template: opts.template,
                 members: cliMemberOverrides(opts.membersFile, commandArgv(command)),
+                anonymous: cliAnonymousOverride(commandArgv(command)),
             });
             const t = result.task;
             auditTask('work', t, previous);
@@ -1414,6 +1430,8 @@ export function registerRoomCommands(parent, cOpt) {
         .description('create a standalone room')
         .requiredOption('--name <name>', 'room name')
         .option('--template <name>', 'room template')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
         .option('--goal <text>', 'room goal')
         .option('--brief <text>', 'room briefing')
         .option('--brief-file <path>', 'room briefing from file')
@@ -1435,6 +1453,7 @@ export function registerRoomCommands(parent, cOpt) {
                 actor: { kind: 'local_control', surface: 'cli' }, name: opts.name,
                 template: opts.template, goal: opts.goal, brief: opts.brief, briefFile: opts.briefFile,
                 members: cliMemberOverrides(opts.membersFile, commandArgv(command)),
+                anonymous: cliAnonymousOverride(commandArgv(command)),
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: record }, null, 2));

package/dist/rooms-tasks/config.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, } from './types.js';
+import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, TEMPLATE_ROOM_KEYS as TRK, } from './types.js';
 const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 const CID_RE = /^[0-9a-fA-F]{64}$/;
 export class RoomsTasksConfigError extends Error {
@@ -153,6 +153,10 @@ export function validateRoomTemplatesConfig(raw, path) {
         if (tplRaw.room !== undefined) {
             if (!isPlainObject(tplRaw.room))
                 throw new RoomsTasksConfigError(path, `room_templates.${name}.room: must be a mapping`);
+            rejectUnknown(tplRaw.room, TRK, path, `room_templates.${name}.room`);
+            for (const key of TRK)
+                if (tplRaw.room[key] !== undefined && typeof tplRaw.room[key] !== 'boolean')
+                    throw new RoomsTasksConfigError(path, `room_templates.${name}.room.${key}: must be a boolean`);
             room = {
                 quiet_membership: tplRaw.room.quiet_membership,
                 anonymous: tplRaw.room.anonymous,

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

@@ -33,6 +33,7 @@ export interface CoworkRoomInfo {
     identity_cid: string;
     room_name: string;
     state: 'provisioning' | 'active' | 'closing' | 'closed';
+    anonymous: boolean;
     seats: CoworkSeatInfo[];
     goal?: string;
     briefing?: string;

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

@@ -47,6 +47,11 @@ function roomState(value, operation) {
         throw new CoworkProtocolError(operation, 'room state is invalid');
     return value;
 }
+function boolean(value, operation, label) {
+    if (typeof value !== 'boolean')
+        throw new CoworkProtocolError(operation, `${label} must be a boolean`);
+    return value;
+}
 function seatState(value, operation) {
     if (value !== 'pending' && value !== 'active' && value !== 'removed')
         throw new CoworkProtocolError(operation, 'seat state is invalid');
@@ -86,6 +91,7 @@ function projectRoom(value, operation) {
         identity_cid: text(room.identity_cid, operation, 'room.identity_cid'),
         room_name: string(room.room_name, operation, 'room.room_name'),
         state: roomState(room.state, operation),
+        anonymous: room.anonymous === undefined ? false : boolean(room.anonymous, operation, 'room.anonymous'),
         seats: room.seats.map((seat) => projectSeat(seat, operation)),
         role_briefings: projectedBriefings,
         ...(typeof mission?.goal === 'string' ? { goal: mission.goal } : {}),

package/dist/rooms-tasks/provision.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { parse } from 'yaml';
 import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, activateRoom, getRoomRecord, } from './room-state.js';
 import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
+import { storedRoomLaunchPolicy } from './types.js';
 import { spawnTemp } from '../spawn.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { selectionOrigin, summarizeResolvedLaunch, } from '../lifecycle-summary.js';
@@ -142,7 +143,7 @@ function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCi
         })),
     });
 }
-function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid, expectedInviteId) {
+function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid, expectedInviteId, anonymous = false) {
     const provenance = readProvenance(dir);
     if (provenance?.creationActionId !== actionId || provenance.role !== member.name)
         return false;
@@ -154,6 +155,7 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
             && startup.room_identity_cid === roomIdentityCid
             && startup.identity_name === member.name
             && startup.role === member.coworkRole
+            && (startup.anonymous ?? false) === anonymous
             && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
             && typeof startup.invite === 'string'
@@ -169,16 +171,17 @@ async function retainRunningLaunch(input) {
         .find(candidate => candidate.role_name === member.name);
     const dir = agentDir(member.name, true);
     const taskSha = sha256Text(task);
+    const anonymous = storedRoomLaunchPolicy(getRoomRecord(provision.roomId)?.room_policy).anonymous;
     if ((seat.launch?.state === 'intent' || seat.launch?.state === 'launched'
         || seat.launch?.state === 'failed') && existsSync(dir)) {
-        if (!seat.launch.action_id || !launchMatches(dir, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
+        if (!seat.launch.action_id || !launchMatches(dir, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous)) {
             const provenance = readProvenance(dir);
             const adoptable = (seat.launch.state === 'intent' || seat.launch.state === 'failed')
                 && Boolean(seat.launch.caller_role)
                 && provenance?.surface === 'agent'
                 && provenance.callerRole === seat.launch.caller_role
                 && typeof provenance.creationActionId === 'string'
-                && launchMatches(dir, member, provenance.creationActionId, taskSha, provision.roomId, roomIdentityCid, seat.invite_id);
+                && launchMatches(dir, member, provenance.creationActionId, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous);
             if (!adoptable)
                 throw new Error(`existing launch for ${member.name} does not match its durable intent`);
             updateMemberStartup(provision.roomId, member.name, { launch: {
@@ -218,7 +221,7 @@ async function retainRunningLaunch(input) {
         if (!seat.launch.launch_id || !seat.launch.action_id)
             throw new Error(`missing durable launch identity for disappeared ${member.name}`);
         const archive = await secureStoppedTempArchive(member.name, seat.launch.launch_id);
-        if (!launchMatches(archive, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
+        if (!launchMatches(archive, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous)) {
             throw new Error(`archive for disappeared ${member.name} does not match its durable intent`);
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
@@ -230,7 +233,7 @@ async function retainRunningLaunch(input) {
         if (!seat.launch.action_id)
             throw new Error(`missing action ID for disappeared launch intent ${member.name}`);
         const archive = tempArchiveForCreationAction(member.name, seat.launch.action_id);
-        if (!archive || !launchMatches(archive.path, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
+        if (!archive || !launchMatches(archive.path, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous)) {
             throw new Error(`launch intent for ${member.name} has no exact live or terminated archive evidence`);
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
@@ -300,7 +303,7 @@ async function launchMemberUnlocked(input) {
                 } });
         }
         const supervisor = readTempSupervisor(launchedDir);
-        if (!supervisor || supervisor.role !== member.name || !launchMatches(launchedDir, member, launched.creationActionId, taskSha, provision.roomId, startup.room_identity_cid, startup.invite_id)) {
+        if (!supervisor || supervisor.role !== member.name || !launchMatches(launchedDir, member, launched.creationActionId, taskSha, provision.roomId, startup.room_identity_cid, startup.invite_id, startup.anonymous ?? false)) {
             throw new Error(`new launch for ${member.name} did not persist matching provenance`);
         }
         const presentation = launched.configuration
@@ -371,6 +374,10 @@ function reconcileMemberSeats(roomId, members, observed) {
     updateMemberSeats(roomId, seats);
     return { complete, seats };
 }
+function assertCoworkRoomPolicy(room, expectedAnonymous) {
+    if ((room.anonymous ?? false) !== expectedAnonymous)
+        throw new Error(`Cowork anonymity (${String(room.anonymous ?? false)}) does not match Fleet's durable Room policy (${String(expectedAnonymous)})`);
+}
 export async function provisionMembers(input) {
     const { cfg, cowork, roomId, taskId, template } = input;
     // Deletion-epoch pre-check; each member launch re-checks under the lock.
@@ -387,6 +394,7 @@ export async function provisionMembers(input) {
         throw new Error(`room ${roomId} has no pinned room identity CID`);
     const roomIdentityCid = existing.room_identity_cid;
     const ownerSeatCid = existing.owner_seat_cid ?? null;
+    const roomPolicy = storedRoomLaunchPolicy(existing.room_policy);
     const persistedNames = new Set(existing.member_seats.map(seat => seat.role_name));
     const resuming = members.length > 0
         && members.every(member => persistedNames.has(member.name));
@@ -427,6 +435,7 @@ export async function provisionMembers(input) {
     advanceSaga(roomId, 'join_role_groups', 4);
     try {
         const initialRoom = await cowork.recoverRoom(roomId);
+        assertCoworkRoomPolicy(initialRoom, roomPolicy.anonymous);
         reconcileMemberSeats(roomId, members, initialRoom.seats);
         for (const member of members) {
             const task = tasks.get(member.name);
@@ -463,6 +472,7 @@ export async function provisionMembers(input) {
                         role: member.coworkRole,
                         task,
                         owner_seat_cid: ownerSeatCid,
+                        anonymous: roomPolicy.anonymous,
                     },
                 });
             }
@@ -493,6 +503,7 @@ export async function provisionMembers(input) {
     let delay = policy.initialDelayMs;
     for (;;) {
         const remote = await cowork.recoverRoom(roomId);
+        assertCoworkRoomPolicy(remote, roomPolicy.anonymous);
         const reconciled = reconcileMemberSeats(roomId, members, remote.seats);
         if (reconciled.complete)
             break;

package/dist/rooms-tasks/room-state.d.ts

@@ -9,6 +9,7 @@ export interface CreateRoomInput {
     room_identity_cid?: string;
     task_id?: string;
     template_snapshot?: import('./types.js').TemplateSnapshot;
+    room_policy?: import('./types.js').RoomLaunchPolicy;
 }
 export declare function createRoomRecord(input: CreateRoomInput): RoomOrchestrationRecord;
 export declare function getRoomRecord(id: string): RoomOrchestrationRecord | undefined;