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

package/README.md

@@ -43,7 +43,7 @@ brain: { inline: { harness: codex, session: acp } }
 ## How it works
 
 ```
-~/fleet.yaml + ~/fleet/{agents,roles,brains,room_templates}/*.yaml   your declaration
+~/fleet.yaml + ~/fleet/{agents,agent_templates,roles,brains,room_templates}/*.yaml   your declaration
         │  ours-fleet up
         ▼
 briefing.md per role  ──►  agent session adapter  ──►  ACP client/session  ──►  ACP agent
@@ -356,9 +356,42 @@ defaults:
     max_kb: 1024                        # rotate only above this active-log size
     keep_tail_kb: 256                   # UTF-8 tail; line-aligned when one fits
     max_archives: 12                    # recent beside log; older preserved cold
-Agent document (\`~/fleet/agents/Name.yaml\`):
-  role: { ref: RoleID }
-  brain: { ref: BrainID }                # Brain owns harness/model/session/reasoning
+```
+
+Agent Template document (\`~/fleet/agent_templates/Worker.yaml\`) is inert and reusable:
+
+```yaml
+role: { ref: developer }
+brain: { ref: claude-default }
+permissions: { approval: ask, filesystem: workspace, unattended: deny }
+```
+
+Persistent Agent instance (\`~/fleet/agents/Name.yaml\`) either remains a canonical
+Role/Brain composition or explicitly reuses a template:
+
+```yaml
+template: Worker
+overrides:
+  cwd: /work/name
+  permissions: { approval: allow }
+```
+
+Templates never create identities, supervisors, sessions, or lifecycle/status rows.
+Map overrides merge recursively; scalars and arrays replace; null deletion is rejected.
+
+Canonical Agent document (\`~/fleet/agents/Name.yaml\`):
+
+```yaml
+role: { ref: RoleID }
+brain: { ref: BrainID }                  # Brain owns harness/model/session/reasoning
+identity: "Display Name"                # ours identity to bind (default: Name)
+cwd: ${work_root}/repo                   # where the harness process runs
+coordinator: FleetCoordinator            # announce target on boot
+```
+
+Additional operational field inventory (schematic, not one YAML document):
+
+```text
     identity: "Display Name"            # ours identity to bind (default: Name)
     cwd: ${work_root}/repo              # where the harness process runs
     coordinator: FleetCoordinator       # announce target on boot
@@ -458,8 +491,11 @@ the packaged preset revision and source directory and only seeds missing files.
 It never upgrades an edited preset. To adopt a newer packaged file explicitly,
 copy the reported source file beside the existing target as `.new-default`, review
 `diff -u`, then replace the target yourself. This is the sole adoption operation;
-rerunning init is not an update. Users upgrading from hardcoded templates should
-run init once (with the same `-c` selection they normally use).
+rerunning init is not an update. Users with the exact generated six-worker legacy
+starter set must migrate explicitly: first run `ours-fleet migrate-agent-templates -c FILE`
+for a zero-write plan, then review every move/addition/recovery path and rerun with
+`--write`. Customized or ambiguous known starters are refused without
+mutation; unrelated custom persistent Agents are preserved.
 
 Rooms always use `ours-cowork`; there is no room-provider selector. Configure
 the cowork daemon connection and the room owner directly:

package/dist/application/fleet-query-service.js

@@ -76,7 +76,8 @@ export class FleetQueryService {
         this.control = options.control ?? controlRequest;
     }
     async list() {
-        const roles = await this.options.repository.list();
+        const roles = (await this.options.repository.list())
+            .filter(role => role.configured && role.lifetime === 'permanent');
         return Promise.all(roles.map(async (role) => {
             const status = await this.status(role);
             return { role, status, capabilities: roleCapabilities(role, status, this.options.capabilityContext) };

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

@@ -12,6 +12,10 @@ export class RoleLifecycleService {
         const config = input.config ?? loadConfig(this.options.configPath);
         const selected = input.roleIds.length ? input.roleIds : config.roles.map(role => role.name);
         for (const roleId of selected) {
+            if (config.agentTemplates?.[roleId] && !config.roles.some(role => role.name === roleId))
+                throw new FleetError('capability_unavailable', `'${roleId}' is an inert Agent Template; lifecycle commands target only persistent fleet/agents instances`);
+            if (!config.roles.some(role => role.name === roleId))
+                throw new FleetError('role_not_found', `no such role '${roleId}'`);
             const role = await this.options.repository.get(roleId);
             if (!role)
                 throw new FleetError('role_not_found', `no such role '${roleId}'`);
@@ -51,6 +55,11 @@ export class RoleCommandService {
                 throw new FleetError('idempotency_conflict', 'action ID already belongs to another operation');
             return prior;
         }
+        const config = loadConfig(this.options.configPath);
+        if (config.agentTemplates?.[input.roleId] && !config.roles.some(role => role.name === input.roleId))
+            throw new FleetError('capability_unavailable', `'${input.roleId}' is an inert Agent Template; lifecycle commands target only persistent fleet/agents instances`);
+        if (!config.roles.some(role => role.name === input.roleId))
+            throw new FleetError('role_not_found', `no such role '${input.roleId}'`);
         const role = await this.options.repository.get(input.roleId);
         if (!role)
             throw new FleetError('role_not_found', `no such role '${input.roleId}'`);

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

@@ -2,6 +2,7 @@ import { type FleetConfig } from '../config.js';
 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';
 export type TaskRoomActor = {
     kind: 'local_control';
@@ -57,6 +58,7 @@ export interface CreateTaskRequest {
     idempotencyKey?: string;
     origin: TaskOrigin;
     list?: string;
+    members?: MemberOverrides;
 }
 export interface CreateRoomRequest {
     actor: TaskRoomActor;
@@ -65,6 +67,7 @@ export interface CreateRoomRequest {
     goal?: string;
     brief?: string;
     briefFile?: string;
+    members?: MemberOverrides;
 }
 export interface TaskRoomServiceDeps {
     loadConfiguration?(path?: string): FleetConfig;
@@ -84,6 +87,8 @@ export declare class TaskRoomApplicationService {
     startTask(input: {
         actor: TaskRoomActor;
         taskId: string;
+        template?: string;
+        members?: MemberOverrides;
     }): Promise<TaskRecord>;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
@@ -252,6 +257,7 @@ export declare class TaskRoomApplicationService {
         actor: TaskRoomActor;
         taskId: string;
         template?: string;
+        members?: MemberOverrides;
     }): Promise<{
         task: TaskRecord;
         status: 'ready' | 'already_active';

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

@@ -4,10 +4,12 @@ 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, } from '../rooms-tasks/task-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 { 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 { 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';
@@ -73,19 +75,46 @@ export class TaskRoomApplicationService {
     }
     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,
-        };
+        let template = this.createTemplate(cfg, request.template, request.noRoom);
+        let launchDefinitions;
+        let executionPlan;
+        let preparedPlan;
+        if (template) {
+            const definition = resolveTemplate(template.name, cfg.roomTemplates ?? {});
+            preparedPlan = prepareExecutionPlan(definition, cfg, request.members ?? {});
+            launchDefinitions = preparedPlan.launchDefinitions;
+        }
         const brief = request.briefFile ? readFileSync(request.briefFile, 'utf8') : request.brief;
-        let task = await withTaskListsLock(() => {
-            const list = resolveTaskList(request.list ?? 'default');
-            return 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, listId: list.list_id,
+        const unlock = preparedPlan ? acquireLaunchSnapshotLock() : undefined;
+        let sealedHash;
+        let task;
+        try {
+            if (preparedPlan) {
+                template = sealTemplateSnapshot(preparedPlan.snapshot, cfg.agentTemplates ?? {}, preparedPlan.launchDefinitions);
+                sealedHash = template.launch_snapshot_hash;
+                executionPlan = { schema_version: 1, snapshot: template, overrides: preparedPlan.overrides,
+                    overrides_hash: preparedPlan.overridesHash,
+                    plan_hash: preparedPlan.planHash };
+            }
+            const ref = template && { name: template.name, version: template.version, content_hash: template.content_hash };
+            task = await withTaskListsLock(() => {
+                const list = resolveTaskList(request.list ?? 'default');
+                return persistTask({
+                    title: request.title, brief, brief_file: request.briefFile, template: ref,
+                    execution_plan: executionPlan,
+                    origin: request.origin, idempotency_key: request.idempotencyKey,
+                    start: !request.backlog, no_room: request.noRoom, listId: list.list_id,
+                });
             });
-        });
+        }
+        catch (error) {
+            unlock?.();
+            if (sealedHash)
+                releaseLaunchSnapshot(sealedHash);
+            throw error;
+        }
+        unlock?.();
+        const ref = template && { name: template.name, version: template.version, content_hash: template.content_hash };
         recordFleetAuditPresentation({ kind: 'task', operation: 'create', id: task.task_id,
             title: task.title, previousState: 'none', newState: task.state, revision: task.created_at,
             list: task.list_name ?? 'default', roomId: task.room_id,
@@ -95,7 +124,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);
                 task = readTask(task.task_id);
                 if (task.state === 'active' && room.state === 'active')
                     recordFleetAuditPresentation({ kind: 'task', operation: 'work', id: task.task_id,
@@ -127,47 +156,19 @@ export class TaskRoomApplicationService {
             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);
+            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);
+            }
+            template = snapshotTemplate(definition, cfg.agentTemplates);
         }
         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);
-        recordFleetAuditPresentation({ kind: 'task', operation: 'start', id: task.task_id,
-            title: task.title, previousState: 'backlog', newState: task.state,
-            revision: task.started_at ?? task.created_at, list: task.list_name ?? 'default',
-            template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
-            agents: [] });
-        if (task.template && !task.room_id) {
-            const template = this.existingTemplate(cfg, task);
-            try {
-                const room = await this.provisionRoom(cfg, task, template, created => {
-                    task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
-                });
-                task = readTask(task.task_id);
-                if (task.state === 'active' && room.state === 'active')
-                    recordFleetAuditPresentation({ kind: 'task', operation: 'work', id: task.task_id,
-                        title: task.title, previousState: 'provisioning', newState: task.state,
-                        revision: getRoomRecord(task.room_id)?.activated_at ?? task.started_at ?? task.created_at,
-                        list: task.list_name ?? 'default', roomId: task.room_id,
-                        template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
-                        agents: taskAgents(task) });
-                else
-                    recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: task.task_id,
-                        state: task.state, category: 'provision_pending', eventId: roomFailureEventId(room) });
-            }
-            catch (error) {
-                const failed = task.room_id ? getRoomRecord(task.room_id) : undefined;
-                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: task.task_id,
-                    state: readTask(task.task_id).state, category: 'provision_failed',
-                    eventId: failed ? roomFailureEventId(failed) : task.created_at });
-                throw error;
-            }
-        }
-        return task;
+        return (await this.ensureTaskWork(input)).task;
     }
     listTasks(filter) {
         const listId = filter?.list === undefined ? undefined : resolveTaskList(filter.list).list_id;
@@ -345,11 +346,9 @@ export class TaskRoomApplicationService {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return listTemplates(cfg.roomTemplates ?? {}).flatMap(template => {
             const issues = template.members.flatMap(member => {
-                if (!('ref' in member.agent))
-                    return [];
-                const ref = member.agent.ref;
-                return cfg.roles.some(role => role.name === ref)
-                    ? [] : [`member ${member.slot}: Agent ref '${ref}' not found`];
+                const ref = member.agent_template;
+                return cfg.agentTemplates?.[ref]
+                    ? [] : [`member ${member.slot}: Agent Template '${ref}' not found`];
             });
             return issues.length ? [{ template: `${template.name}@${template.version}`, issues }] : [];
         });
@@ -503,53 +502,101 @@ export class TaskRoomApplicationService {
         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 (input.template || input.members) {
+                const pinned = getRoomRecord(task.room_id)?.template_snapshot ?? task.execution_plan?.snapshot;
+                if (!pinned)
+                    throw new TaskRoomApplicationError('template_mismatch', 'active task has no durable execution plan', { room: task.room_id });
+                const templateName = input.template ?? pinned.name;
+                if ((!input.template || input.template === pinned.name) && input.members
+                    && task.execution_plan?.overrides_hash === hashMemberOverrides(input.members))
+                    return { task, status: 'already_active' };
+                const definition = resolveTemplate(templateName, 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_not_found', 'template not found', { template: templateName });
+                const requested = prepareExecutionPlan(definition, cfg, input.members ?? {});
+                const pinnedPlanHash = task.execution_plan?.plan_hash ?? pinned.content_hash;
+                if (pinned.name !== requested.snapshot.name || pinnedPlanHash !== requested.planHash)
                     throw new TaskRoomApplicationError('template_mismatch', 'template mismatch', {
-                        requested: `${requested.name}@${requested.version}`, room: task.room_id,
+                        requested: `${requested.snapshot.name}@${requested.snapshot.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;
+        const durable = room?.template_snapshot ?? task.execution_plan?.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`);
+            throw new Error(`task ${task.task_id} template reference does not match its durable execution 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
+        const storedOverridesMatch = !!(durable && input.members && task.execution_plan?.overrides_hash
+            === hashMemberOverrides(input.members));
+        const definition = durable && !input.template && (!input.members || storedOverridesMatch) ? 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);
+        let launchDefinitions;
+        let preparedPlan = !durable && definition
+            ? prepareExecutionPlan(definition, cfg, input.members ?? {}) : undefined;
+        let snapshot = durable ?? preparedPlan.snapshot;
+        if (preparedPlan)
+            launchDefinitions = preparedPlan.launchDefinitions;
+        if (input.members && Object.keys(input.members).length && !storedOverridesMatch) {
+            if (!definition)
+                throw new TaskRoomApplicationError('template_mismatch', 'member overrides cannot change an existing Room execution plan');
+            const prepared = preparedPlan ?? prepareExecutionPlan(definition, cfg, input.members);
+            preparedPlan = prepared;
+            if (durable && prepared.planHash !== durable.content_hash)
+                throw new TaskRoomApplicationError('template_mismatch', 'member overrides do not match existing execution plan');
+            snapshot = prepared.snapshot;
+            launchDefinitions = prepared.launchDefinitions;
+        }
         if (durable && input.template && definition) {
-            const requested = snapshotTemplate(definition);
+            const requested = snapshotTemplate(definition, cfg.agentTemplates);
             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 (!input.template && task.template && snapshot.content_hash !== task.template.content_hash) {
+            // Pre-execution-plan backlog records used the template-only hash. Accept
+            // that exact legacy pin once, then upgrade it to the complete sealed plan.
+            const legacyHash = definition
+                ? snapshotTemplate(definition, cfg.agentTemplates).content_hash : undefined;
+            if (task.template.content_hash !== legacyHash)
+                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)
+        if (preparedPlan && !task.room_id) {
+            const unlock = acquireLaunchSnapshotLock();
+            let sealed;
+            try {
+                sealed = sealTemplateSnapshot(snapshot, cfg.agentTemplates ?? {}, launchDefinitions);
+                task = updateTaskExecutionPlan(task.task_id, { schema_version: 1, snapshot: sealed,
+                    overrides: preparedPlan.overrides, overrides_hash: preparedPlan.overridesHash,
+                    plan_hash: preparedPlan.planHash });
+                snapshot = sealed;
+            }
+            catch (error) {
+                unlock();
+                if (sealed?.launch_snapshot_hash)
+                    releaseLaunchSnapshot(sealed.launch_snapshot_hash);
+                throw error;
+            }
+            unlock();
+        }
+        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') {
             task = transitionTask(task.task_id);
@@ -562,7 +609,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);
                 task = readTask(task.task_id);
             }
             catch (error) {
@@ -619,17 +666,17 @@ export class TaskRoomApplicationService {
                 throw new TaskRoomApplicationError('template_not_found', `template not found: ${requested}`);
             return undefined;
         }
-        return snapshotTemplate(definition);
+        return snapshotTemplate(definition, cfg.agentTemplates);
     }
     existingTemplate(cfg, task) {
         const ref = task.template;
         const definition = resolveTemplate(ref.name, cfg.roomTemplates ?? {});
-        const snapshot = definition ? snapshotTemplate(definition) : undefined;
+        const snapshot = definition ? snapshotTemplate(definition, cfg.agentTemplates) : 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) {
+    async provisionRoom(cfg, task, template, onCreated, launchDefinitions) {
         const rooms = cfg.rooms;
         if (!rooms)
             throw new ConfigError('rooms: configuration is required');
@@ -641,16 +688,31 @@ export class TaskRoomApplicationService {
                 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,
-        });
+        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,
+            });
+        }
+        catch (error) {
+            unlockSnapshot?.();
+            if (launchTemplate?.launch_snapshot_hash)
+                releaseLaunchSnapshot(launchTemplate.launch_snapshot_hash);
+            throw error;
+        }
+        unlockSnapshot?.();
         recordFleetAuditPresentation({ kind: 'room', operation: 'create', id: room.room_id,
             name: room.room_name, previousState: 'none', newState: 'provisioning',
             revision: room.created_at, taskId: room.task_id,
@@ -677,10 +739,10 @@ export class TaskRoomApplicationService {
             }
         }
         room = advanceSaga(room.room_id, 'create_members', 3);
-        if (template?.members.length)
+        if (launchTemplate?.members.length)
             try {
                 room = await (this.deps.provisionMembers ?? provisionMembers)({
-                    cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
+                    cfg, cowork, roomId: room.room_id, taskId: task.task_id, template: launchTemplate,
                     binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief,
                     goal: task.task_id ? task.title : task.goal,
                 });
@@ -702,7 +764,7 @@ export class TaskRoomApplicationService {
         else
             recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room', id: room.room_id,
                 state: room.state, category: 'provision_pending', eventId: roomFailureEventId(room) });
-        if (task.task_id && !template?.members.length)
+        if (task.task_id && !launchTemplate?.members.length)
             activateTask(task.task_id);
         return room;
     }

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.10",
-  "buildId": "7fbfbd6e4119",
-  "commit": "006179e6e9ae9d9e846045a658a64686c8169ebe",
+  "version": "1.1.0-nightly.12",
+  "buildId": "6da038d91a6d",
+  "commit": "57faa7ff79b4097ac94797b9a591ce54aad01c0a",
   "dirty": true,
-  "builtAt": "2026-08-31T14:07:48.123Z",
+  "builtAt": "2026-08-31T21:40:11.904Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/canonical-json.d.ts

@@ -0,0 +1,2 @@
+/** Stable JSON used for semantic configuration fingerprints. */
+export declare function canonicalJson(value: unknown): string;

package/dist/canonical-json.js

@@ -0,0 +1,10 @@
+/** Stable JSON used for semantic configuration fingerprints. */
+export function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(',')}}`;
+    return JSON.stringify(value);
+}