@ours.network/fleet 1.0.2 → 1.0.4

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

@@ -0,0 +1,529 @@
+import { readFileSync } from 'node:fs';
+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, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, } from '../rooms-tasks/task-state.js';
+import { hashTemplate, listTemplates, resolveTemplate, snapshotTemplate } from '../rooms-tasks/templates.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';
+export class TaskRoomApplicationError extends Error {
+    code;
+    fields;
+    constructor(code, message, fields = {}) {
+        super(message);
+        this.code = code;
+        this.fields = fields;
+        this.name = 'TaskRoomApplicationError';
+    }
+}
+/** Exact extraction of the previously CLI-owned task create/start behavior. */
+export class TaskRoomApplicationService {
+    configurationPath;
+    deps;
+    recovery;
+    constructor(configurationPath, deps = {}) {
+        this.configurationPath = configurationPath;
+        this.deps = deps;
+    }
+    async createTask(request) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        const template = this.createTemplate(cfg, request.template, request.noRoom);
+        const ref = template && {
+            name: template.name, version: template.version, content_hash: template.content_hash,
+        };
+        const brief = request.briefFile ? readFileSync(request.briefFile, 'utf8') : request.brief;
+        let task = persistTask({
+            title: request.title, brief, brief_file: request.briefFile, template: ref,
+            origin: request.origin, idempotency_key: request.idempotencyKey,
+            start: !request.backlog,
+            no_room: request.noRoom,
+        });
+        if (!request.backlog && !request.noRoom && ref && !task.room_id) {
+            try {
+                await this.provisionRoom(cfg, task, template, room => {
+                    task = updateTaskRoom(task.task_id, room.room_id, room.room_identity_cid);
+                });
+                task = readTask(task.task_id);
+            }
+            catch (error) {
+                if (error instanceof CoworkUnavailableError)
+                    persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                throw error;
+            }
+        }
+        return task;
+    }
+    async createRoom(request) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        const brief = request.briefFile ? readFileSync(request.briefFile, 'utf8') : request.brief;
+        let template;
+        if (request.template) {
+            const definition = resolveTemplate(request.template, cfg.roomTemplates ?? {});
+            if (!definition)
+                throw new TaskRoomApplicationError('template_not_found', `template not found: ${request.template}`, { template: request.template });
+            template = snapshotTemplate(definition);
+        }
+        return this.provisionRoom(cfg, {
+            title: request.name, brief, goal: request.goal,
+        }, template, () => { });
+    }
+    async startTask(input) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        let task = transitionTask(input.taskId);
+        if (task.template && !task.room_id) {
+            const template = this.existingTemplate(cfg, task);
+            await this.provisionRoom(cfg, task, template, room => {
+                task = updateTaskRoom(task.task_id, room.room_id, room.room_identity_cid);
+            });
+            task = readTask(task.task_id);
+        }
+        return task;
+    }
+    listTasks(filter) {
+        return readTasks(filter);
+    }
+    getTask(taskId) {
+        const task = readTask(taskId);
+        return { task, orchestration: task.room_id ? getRoomRecord(task.room_id) : undefined };
+    }
+    blockTask(input) {
+        return persistBlockTask(input.taskId, input.reason);
+    }
+    unblockTask(input) {
+        return persistUnblockTask(input.taskId);
+    }
+    reviewTask(input) {
+        return persistReviewTask(input.taskId);
+    }
+    deleteTask(input) {
+        return persistDeleteTask(input.taskId);
+    }
+    async completeTask(input) {
+        const task = readTask(input.taskId);
+        if (TASK_TERMINAL_STATES.includes(task.state))
+            throw new TaskStateError(`task ${input.taskId} is already in terminal state '${task.state}'`);
+        if (task.state !== 'review')
+            throw new TaskStateError(`cannot transition from '${task.state}' to 'done'`);
+        let roomId;
+        if (task.room_id) {
+            const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+            const shouldClose = cfg.tasks?.close_room_on_done
+                ?? cfg.rooms?.defaults?.close_when_task_done ?? false;
+            if (shouldClose)
+                roomId = task.room_id;
+        }
+        return this.acceptTerminal(input.taskId, 'done', roomId, input.outcome);
+    }
+    async cancelTask(input) {
+        const task = readTask(input.taskId);
+        if (!TASK_CANCELLABLE_STATES.includes(task.state))
+            throw new TaskStateError(`cannot cancel a '${task.state}' task`);
+        if (task.room_id)
+            (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        return this.acceptTerminal(input.taskId, 'cancelled', task.room_id);
+    }
+    async settleTask(input) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        if (!cfg.rooms)
+            throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+        const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({
+            configPath: cfg.rooms.cowork?.config,
+        });
+        return settleTaskTerminalIntent({ taskId: input.taskId, cowork });
+    }
+    recordSettlementError(input) {
+        return recordTaskTerminalIntentError(input.taskId, input.error, input.recoveryHint);
+    }
+    async beginTaskRecovery(input) {
+        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')
+            return { kind: 'terminal_worker_required', taskId: input.taskId };
+        return { kind: 'final', result: await this.continueTaskRecovery({
+                actor: input.actor, taskId: input.taskId, terminalTimedOut: false,
+            }) };
+    }
+    async continueTaskRecovery(input) {
+        if (!this.recovery || this.recovery.taskId !== input.taskId)
+            throw new Error('task recovery continuation requires a matching begin');
+        const recovery = this.recovery;
+        this.recovery = undefined;
+        const cfg = recovery.config;
+        let task = readTask(input.taskId);
+        let room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+        const issues = input.terminalTimedOut ? [{ code: 'terminal_pending' }] : [];
+        if (task.state !== 'provisioning')
+            return {
+                kind: TASK_TERMINAL_STATES.includes(task.state) ? 'terminal' : 'no_op', task, room, issues,
+            };
+        if (!room)
+            return { kind: 'provisioning_non_resumable', task, room, issues, reason: 'missing_room' };
+        if (room.provisioning_detail === 'waiting_cowork')
+            issues.push({ code: 'waiting_cowork' });
+        if (room.provisioning_detail === 'waiting_owner_invite')
+            issues.push({ code: 'waiting_owner_invite' });
+        if (room.provisioning_detail === 'owner_cid_mismatch')
+            issues.push({ code: 'owner_cid_mismatch' });
+        if (room.provisioning_detail === 'member_failed')
+            issues.push({ code: 'member_failed', stepIndex: room.saga.step_index });
+        if (room.provisioning_detail === 'waiting_seats')
+            issues.push({ code: 'waiting_seats' });
+        const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
+        if (!resumable.includes(room.saga.phase))
+            return {
+                kind: 'provisioning_non_resumable', task, room, issues, reason: 'non_resumable_phase',
+            };
+        const template = room.template_snapshot;
+        if (!template)
+            throw new Error(`room ${room.room_id} has no durable template snapshot`);
+        if (!task.template || task.template.name !== template.name
+            || task.template.version !== template.version || task.template.content_hash !== template.content_hash)
+            throw new Error(`task ${task.task_id} template reference does not match room ${room.room_id}'s durable snapshot`);
+        try {
+            if (!cfg.rooms)
+                throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+            const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+            await (this.deps.provisionMembers ?? provisionMembers)({
+                cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
+                binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief, goal: task.title,
+            });
+            task = readTask(task.task_id);
+            room = getRoomRecord(room.room_id);
+            return { kind: 'provisioning_resumed', task, room, issues: [{ code: 'provisioning_resumed' }] };
+        }
+        catch (error) {
+            issues.push({ code: 'resume_failed', error: error instanceof Error ? error.message : String(error) });
+            return { kind: 'provisioning_resume_failed', task, room, issues };
+        }
+    }
+    async acceptTerminal(taskId, kind, roomId, outcome) {
+        const task = await acceptTaskTerminalIntent({ taskId, kind, roomId, outcome });
+        return { task, settlementRequired: task.terminal_intent?.status === 'pending' && !!roomId };
+    }
+    listTemplates() {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        return listTemplates(cfg.roomTemplates ?? {});
+    }
+    getTemplate(name) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        const template = resolveTemplate(name, cfg.roomTemplates ?? {});
+        if (!template)
+            throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: name });
+        return { ...template, content_hash: hashTemplate(template) };
+    }
+    validateTemplates() {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        return listTemplates(cfg.roomTemplates ?? {}).flatMap(template => {
+            const issues = template.members.flatMap(member => cfg.roles.some(role => role.name === member.role_ref)
+                ? [] : [`member ${member.slot}: role_ref '${member.role_ref}' not found in fleet roles`]);
+            return issues.length ? [{ template: `${template.name}@${template.version}`, issues }] : [];
+        });
+    }
+    async listRooms(filter) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        if (!cfg.rooms)
+            throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+        const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+        await deleteLegacyClosedRooms({ cowork });
+        const local = new Map(listRoomRecords().map(room => [room.room_id, room]));
+        return (await cowork.listRooms()).filter(room => room.state === 'active' || room.state === 'provisioning')
+            .filter(room => {
+            const tracked = local.get(room.room_id);
+            return !tracked || tracked.state === 'active' || tracked.state === 'provisioning';
+        })
+            .filter(room => !filter?.state || room.state === filter.state)
+            .map(room => ({ ...room, orchestration: local.get(room.room_id) ?? null }));
+    }
+    async getRoomDetail(id) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        const orchestration = getRoomRecord(id);
+        if (orchestration?.state === 'closing' || orchestration?.state === 'closed')
+            throw new TaskRoomApplicationError('room_not_found', 'room not found', { room: id });
+        if (!cfg.rooms)
+            throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+        const adapter = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+        const room = await adapter.getRoom(id);
+        if (!room || room.state === 'closing' || room.state === 'closed')
+            throw new TaskRoomApplicationError('room_not_found', 'room not found', { room: id });
+        return { room, orchestration };
+    }
+    async getRoomMembers(id) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        const orchestration = getRoomRecord(id);
+        if (orchestration?.state === 'closing' || orchestration?.state === 'closed')
+            throw new TaskRoomApplicationError('room_not_found', 'room not found', { room: id });
+        if (!cfg.rooms)
+            throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+        const adapter = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+        const room = await adapter.getRoom(id);
+        if (!room || room.state === 'closing' || room.state === 'closed')
+            throw new TaskRoomApplicationError('room_not_found', 'room not found', { room: id });
+        return { room, orchestration, members: await adapter.getSeats(id) };
+    }
+    async requestRoomDeletion(input) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        if (!cfg.rooms)
+            throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+        if (this.deps.cowork)
+            this.deps.cowork(cfg);
+        else
+            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: await acceptManagedRoomClose(input.roomId), settlementRequired: true };
+    }
+    async settleRoomDeletion(input) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        if (!cfg.rooms)
+            throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+        const cowork = this.deps.cowork ? this.deps.cowork(cfg)
+            : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+        return deleteManagedRoom({ roomId: input.roomId, cowork });
+    }
+    recordRoomSettlementError(input) {
+        return recordManagedRoomCloseError(input.roomId, input.error, input.recoveryHint);
+    }
+    async recoverRoom(input) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        if (!cfg.rooms)
+            throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+        const adapter = this.deps.cowork ? this.deps.cowork(cfg)
+            : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+        let orchestration = getRoomRecord(input.roomId);
+        if (orchestration?.state === 'closing' || orchestration?.state === 'closed')
+            return { kind: 'deletion_worker_required', roomId: input.roomId };
+        const room = await adapter.recoverRoom(input.roomId);
+        orchestration = getRoomRecord(input.roomId);
+        if (orchestration && !orchestration.owner_seat_cid
+            && (orchestration.provisioning_detail === 'waiting_owner_invite'
+                || orchestration.provisioning_detail === 'owner_cid_mismatch')) {
+            const expected = cfg.rooms.owner.expected_cid.toLowerCase();
+            const existing = (await adapter.getSeats(input.roomId))
+                .find(seat => seat.identity_cid.toLowerCase() === expected && seat.seat_state !== 'removed');
+            if (!existing && !cfg.ownerInvite)
+                throw new ConfigError('rooms.owner: configure public_invite or public_invite_file before recovery');
+            let acceptedCid = existing?.identity_cid;
+            if (!acceptedCid)
+                acceptedCid = (await adapter.acceptInvite(input.roomId, cfg.ownerInvite, {
+                    role: cfg.rooms.owner.role, expected_cid: cfg.rooms.owner.expected_cid,
+                })).seat_cid;
+            setOwnerSeat(input.roomId, acceptedCid, cfg.ownerInviteFingerprint ?? '');
+            orchestration = advanceSaga(input.roomId, 'create_members', 3);
+        }
+        const issues = [];
+        if (orchestration?.saga.error)
+            issues.push('A provisioning failure is recorded; inspect role logs for diagnostics.');
+        if (orchestration?.saga.recovery_hint)
+            issues.push('Recovery guidance is recorded; inspect role logs for diagnostics.');
+        if (orchestration?.provisioning_detail === 'waiting_cowork')
+            issues.push('Check ours-cowork service status');
+        if (orchestration?.provisioning_detail === 'waiting_owner_invite')
+            issues.push('Rotate rooms.owner.public_invite in config, then re-run recover');
+        if (orchestration?.provisioning_detail === 'waiting_seats')
+            issues.push('Inspect temporary member logs for invite acceptance, then re-run recover');
+        if (orchestration?.state === 'provisioning'
+            && ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'].includes(orchestration.saga.phase)
+            && orchestration.template_snapshot) {
+            try {
+                let template = orchestration.template_snapshot;
+                let brief;
+                let goal = orchestration.room_name;
+                if (orchestration.task_id) {
+                    const task = readTask(orchestration.task_id);
+                    if (!task.template || task.template.name !== template.name || task.template.version !== template.version
+                        || task.template.content_hash !== template.content_hash)
+                        throw new Error(`task ${task.task_id} template reference does not match room ${orchestration.room_id}'s durable snapshot`);
+                    brief = task.brief;
+                    goal = task.title;
+                }
+                await (this.deps.provisionMembers ?? provisionMembers)({ cfg, cowork: adapter,
+                    roomId: orchestration.room_id, taskId: orchestration.task_id, template,
+                    binPath: (this.deps.binPath ?? getBinPath)(), brief, goal });
+                orchestration = getRoomRecord(input.roomId);
+                return { kind: 'provisioning_resumed', room, orchestration,
+                    issues: ['Provisioning resumed successfully'] };
+            }
+            catch (error) {
+                issues.push(`Resume failed: ${error instanceof Error ? error.message : String(error)}`);
+                return { kind: 'provisioning_resume_failed', room, orchestration, issues };
+            }
+        }
+        return { kind: 'recovered', room, orchestration, issues };
+    }
+    async finishTask(input) {
+        let task = readTask(input.taskId);
+        if (TASK_TERMINAL_STATES.includes(task.state))
+            throw new TaskRoomApplicationError('task_terminal_already', 'task already terminal', { task: input.taskId, state: task.state });
+        if (task.state === 'active')
+            task = persistReviewTask(task.task_id);
+        if (task.room_id)
+            (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        return this.acceptTerminal(task.task_id, 'done', task.room_id, input.outcome);
+    }
+    async ensureTaskWork(input) {
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        let task = readTask(input.taskId);
+        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) {
+            if (input.template) {
+                const definition = resolveTemplate(input.template, cfg.roomTemplates ?? {});
+                if (!definition)
+                    throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: input.template });
+                const requested = snapshotTemplate(definition);
+                const pinned = getRoomRecord(task.room_id)?.template_snapshot ?? task.template;
+                if (pinned && (pinned.name !== requested.name || pinned.content_hash !== requested.content_hash))
+                    throw new TaskRoomApplicationError('template_mismatch', 'template mismatch', {
+                        requested: `${requested.name}@${requested.version}`, room: task.room_id,
+                        provisioned: `${pinned.name}@${pinned.version}`
+                    });
+            }
+            return { task, status: 'already_active' };
+        }
+        const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+        const durable = room?.template_snapshot;
+        if (durable && (!task.template || task.template.name !== durable.name
+            || task.template.version !== durable.version || task.template.content_hash !== durable.content_hash))
+            throw new Error(`task ${task.task_id} template reference does not match room ${room.room_id}'s durable snapshot`);
+        const templateName = input.template ?? durable?.name ?? task.template?.name
+            ?? cfg.tasks?.default_room_template ?? cfg.rooms?.defaults?.template ?? 'single';
+        const definition = durable && !input.template ? undefined
+            : resolveTemplate(templateName, cfg.roomTemplates ?? {});
+        if (input.template && !definition)
+            throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });
+        if (!durable && !definition)
+            throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });
+        const snapshot = durable ?? snapshotTemplate(definition);
+        if (durable && input.template && definition) {
+            const requested = snapshotTemplate(definition);
+            if (requested.name !== durable.name || requested.content_hash !== durable.content_hash)
+                throw new TaskRoomApplicationError('template_mismatch', 'template mismatch', {
+                    requested: `${requested.name}@${requested.version}`, room: room.room_id,
+                    provisioned: `${durable.name}@${durable.version}`
+                });
+        }
+        if (!input.template && task.template && snapshot.content_hash !== task.template.content_hash)
+            throw new TaskRoomApplicationError('task_template_drift', 'task template drift', {
+                template: `${task.template.name}@${task.template.version}`
+            });
+        if (task.room_id && room?.template_snapshot
+            && (room.template_snapshot.name !== snapshot.name || room.template_snapshot.content_hash !== snapshot.content_hash))
+            throw new TaskRoomApplicationError('template_mismatch', 'template mismatch', {
+                requested: `${snapshot.name}@${snapshot.version}`, room: task.room_id,
+                provisioned: `${room.template_snapshot.name}@${room.template_snapshot.version}`
+            });
+        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')
+            task = transitionTask(task.task_id);
+        if (!task.room_id) {
+            try {
+                await this.provisionRoom(cfg, task, snapshot, created => {
+                    task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
+                });
+                task = readTask(task.task_id);
+            }
+            catch (error) {
+                if (error instanceof CoworkUnavailableError)
+                    persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                throw error;
+            }
+        }
+        else if (task.state === 'provisioning') {
+            if (!room || !['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'].includes(room.saga.phase))
+                throw new TaskRoomApplicationError('task_non_resumable', 'task non-resumable', { task: task.task_id, room: task.room_id });
+            try {
+                if (!cfg.rooms)
+                    throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+                const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+                await (this.deps.provisionMembers ?? provisionMembers)({ cfg, cowork, roomId: room.room_id,
+                    taskId: task.task_id, template: snapshot, binPath: (this.deps.binPath ?? getBinPath)(),
+                    brief: task.brief, goal: task.title });
+                task = readTask(task.task_id);
+            }
+            catch (error) {
+                if (error instanceof CoworkUnavailableError)
+                    persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                throw error;
+            }
+        }
+        return { task, status: 'ready' };
+    }
+    createTemplate(cfg, requested, noRoom) {
+        if (noRoom)
+            return undefined;
+        const name = requested
+            ?? cfg.tasks?.default_room_template ?? cfg.rooms?.defaults?.template ?? 'team';
+        const definition = resolveTemplate(name, cfg.roomTemplates ?? {});
+        if (!definition) {
+            if (requested)
+                throw new TaskRoomApplicationError('template_not_found', `template not found: ${requested}`);
+            return undefined;
+        }
+        return snapshotTemplate(definition);
+    }
+    existingTemplate(cfg, task) {
+        const ref = task.template;
+        const definition = resolveTemplate(ref.name, cfg.roomTemplates ?? {});
+        const snapshot = definition ? snapshotTemplate(definition) : undefined;
+        if (!snapshot || snapshot.content_hash !== ref.content_hash)
+            throw new TaskRoomApplicationError('task_template_drift', `task template snapshot no longer matches ${ref.name}@${ref.version}`);
+        return snapshot;
+    }
+    async provisionRoom(cfg, task, template, onCreated) {
+        const rooms = cfg.rooms;
+        if (!rooms)
+            throw new ConfigError('rooms: configuration is required');
+        const attachOwner = rooms.defaults?.attach_owner !== false;
+        if (attachOwner && !cfg.ownerInvite)
+            throw new ConfigError('rooms.owner: public_invite or public_invite_file is required when attach_owner is enabled');
+        const cowork = this.deps.cowork ? this.deps.cowork(cfg) : (() => {
+            if (!cfg.rooms)
+                throw new ConfigError('rooms: configuration is required before creating or querying rooms');
+            return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+        })();
+        const created = await cowork.createRoom({
+            room_name: task.title, goal: task.goal?.trim() || task.title,
+            briefing: task.brief?.trim() || template?.contract?.trim() || task.goal?.trim() || task.title,
+            quiet_membership: template?.room?.quiet_membership,
+            anonymous: template?.room?.anonymous,
+        });
+        let room = createRoomRecord({
+            room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
+            task_id: task.task_id, template_snapshot: template,
+        });
+        onCreated(room);
+        room = advanceSaga(room.room_id, 'create_room', 1);
+        if (attachOwner) {
+            try {
+                room = advanceSaga(room.room_id, 'attach_owner', 2);
+                const accepted = await cowork.acceptInvite(room.room_id, cfg.ownerInvite, {
+                    role: rooms.owner.role, expected_cid: rooms.owner.expected_cid,
+                });
+                room = setOwnerSeat(room.room_id, accepted.seat_cid, cfg.ownerInviteFingerprint ?? '');
+            }
+            catch (error) {
+                const mismatch = error instanceof CoworkProtocolError && /CID|expected/i.test(error.message);
+                setSagaError(room.room_id, error instanceof Error ? error.message : String(error), mismatch ? 'Verify rooms.owner.expected_cid and rotate the configured invite if necessary.'
+                    : 'Rotate rooms.owner.public_invite or public_invite_file, then run room recover.', mismatch ? 'owner_cid_mismatch' : 'waiting_owner_invite');
+                throw error;
+            }
+        }
+        room = advanceSaga(room.room_id, 'create_members', 3);
+        if (template?.members.length)
+            return (this.deps.provisionMembers ?? provisionMembers)({
+                cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
+                binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief,
+                goal: task.task_id ? task.title : task.goal,
+            });
+        room = activateRoom(room.room_id);
+        if (task.task_id)
+            activateTask(task.task_id);
+        return room;
+    }
+}

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.0.2",
-  "buildId": "130a4cf27fc0",
-  "commit": "24c4ae325fc37fb929ef68342ad603ee9dc1692a",
+  "version": "1.0.4",
+  "buildId": "0891be00930f",
+  "commit": "4f7c7292736219d27e8949442478996191cc2b54",
   "dirty": false,
-  "builtAt": "2026-08-25T13:12:24.502Z",
+  "builtAt": "2026-08-26T06:30:09.239Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]