@ours.network/fleet 1.1.0-nightly.7 → 1.1.0-nightly.9

package/README.md

@@ -43,7 +43,7 @@ brain: { inline: { harness: codex, session: acp } }
 ## How it works
 
 ```
-~/fleet.yaml + ~/fleet/{agents,roles,brains}/*.yaml   your declaration
+~/fleet.yaml + ~/fleet/{agents,roles,brains,room_templates}/*.yaml   your declaration
         │  ours-fleet up
         ▼
 briefing.md per role  ──►  agent session adapter  ──►  ACP client/session  ──►  ACP agent
@@ -91,7 +91,7 @@ equivalent); logs land in `~/.ours-fleet/logs/`.
 
 ```sh
 npm i -g @ours.network/fleet
-ours-fleet init      # units/dirs/linger for this user
+ours-fleet init      # units/dirs/linger + missing standard presets
 ours-fleet doctor    # verifies everything above, with actionable messages
 ```
 
@@ -107,8 +107,8 @@ become that account and repeat.
 ## Quickstart
 
 ```sh
-cp -R "$(npm root -g)/@ours.network/fleet/examples/fleet" ~/fleet
-cp "$(npm root -g)/@ours.network/fleet/examples/fleet.yaml" ~/fleet.yaml
+ours-fleet init               # safe to repeat: creates missing files, never replaces edits
+ours-fleet config             # validates Agents, Roles, Brains, and Room templates
 $EDITOR ~/fleet/agents/*.yaml # compose Role + Brain and operational settings
 ours-fleet up                 # boot the fleet (staggered)
 ours-fleet ls                 # running consoles
@@ -442,6 +442,25 @@ installer/setup flows remain responsible for starting it.
 
 ### Rooms and tasks
 
+Init installs editable `single`, `pair`, and `team` definitions under
+`~/fleet/room_templates/`, plus every exact-cased Agent, Role, and Brain they
+reference. Inspect them with `ours-fleet template list` and
+`ours-fleet template show team`. After configuring the authenticated owner below:
+
+```sh
+ours-fleet task create --title "Solo task" --template single
+ours-fleet task create --title "Reviewed change" --template pair
+ours-fleet task create --title "Phased delivery" --template team
+```
+
+`ours-fleet init -c /path/custom.yaml` seeds `/path/custom/` instead. Init reports
+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).
+
 Rooms always use `ours-cowork`; there is no room-provider selector. Configure
 the cowork daemon connection and the room owner directly:
 

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

@@ -68,7 +68,7 @@ export class RoleCreationService {
                 return `unresolved (${provenance})`;
             if ('ref' in value)
                 return `ref:${value.ref} (${provenance})`;
-            const fingerprint = createHash('sha256').update(JSON.stringify(value.inline)).digest('hex').slice(0, 16);
+            const fingerprint = hash(value.inline).slice(0, 16);
             return `inline:sha256:${fingerprint} (${provenance})`;
         };
         return {

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

@@ -179,7 +179,7 @@ export declare class TaskRoomApplicationService {
         name: string;
         version: number;
         description: string;
-        builtin?: boolean;
+        sourceFile?: string;
         room?: import("../rooms-tasks/types.js").TemplateRoomConfig;
         contract?: string;
         members: import("../rooms-tasks/types.js").TemplateMemberSlot[];

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

@@ -1,10 +1,12 @@
 import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 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 { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked, readTaskLists, renameTaskListLocked, resolveTaskList, TaskListError, withTaskListsLock, } from '../rooms-tasks/task-lists.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';
@@ -19,6 +21,47 @@ export class TaskRoomApplicationError extends Error {
         this.name = 'TaskRoomApplicationError';
     }
 }
+function launchSelection(definition, key) {
+    const selected = definition?.[key];
+    if (!selected || typeof selected !== 'object' || Array.isArray(selected))
+        return undefined;
+    const value = selected;
+    if (value.kind === 'ref' && typeof value.id === 'string')
+        return `ref:${value.id} (reference)`;
+    if (value.kind === 'inline' && typeof value.fingerprint === 'string')
+        return `inline:${value.fingerprint} (inline)`;
+    return undefined;
+}
+function launchPermissions(definition) {
+    const selected = definition?.permissions;
+    if (!selected || typeof selected !== 'object' || Array.isArray(selected))
+        return undefined;
+    const value = selected;
+    const fields = ['approval', 'filesystem', 'unattended'].flatMap(key => typeof value[key] === 'string' ? [`${key}=${value[key]}`] : []);
+    return fields.length ? fields.join(',') : undefined;
+}
+function roomParticipants(room) {
+    return [...room.member_seats].sort((a, b) => a.role_name.localeCompare(b.role_name)).map(seat => ({
+        name: seat.role_name, id: seat.identity_cid,
+        brain: launchSelection(seat.launch?.agent_definition, 'brain'),
+        role: launchSelection(seat.launch?.agent_definition, 'role') ?? seat.cowork_role,
+        permissions: launchPermissions(seat.launch?.agent_definition),
+    }));
+}
+function taskAgents(task) {
+    const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+    const seats = new Map(room?.member_seats.map(seat => [seat.role_name, seat]) ?? []);
+    return [...task.member_roles].sort((a, b) => a.name.localeCompare(b.name)).map(member => {
+        const seat = seats.get(member.name);
+        return { name: member.name, brain: launchSelection(seat?.launch?.agent_definition, 'brain'),
+            role: launchSelection(seat?.launch?.agent_definition, 'role') ?? member.cowork_role,
+            permissions: launchPermissions(seat?.launch?.agent_definition) };
+    });
+}
+function roomFailureEventId(room) {
+    const evidence = `${room.created_at}\0${room.saga.phase}\0${room.saga.step_index}\0${room.saga.error ?? ''}`;
+    return `sha256:${createHash('sha256').update(evidence).digest('hex')}`;
+}
 /** Exact extraction of the previously CLI-owned task create/start behavior. */
 export class TaskRoomApplicationService {
     configurationPath;
@@ -43,16 +86,34 @@ export class TaskRoomApplicationService {
                 start: !request.backlog, no_room: request.noRoom, listId: list.list_id,
             });
         });
+        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,
+            template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+            agents: [] });
         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);
+                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) {
                 if (error instanceof CoworkUnavailableError)
                     persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                    id: task.task_id, state: readTask(task.task_id).state, category: 'provision_failed',
+                    eventId: task.room_id ? roomFailureEventId(getRoomRecord(task.room_id)) : task.created_at });
                 throw error;
             }
         }
@@ -75,12 +136,36 @@ export class TaskRoomApplicationService {
     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);
-            await this.provisionRoom(cfg, task, template, room => {
-                task = updateTaskRoom(task.task_id, room.room_id, room.room_identity_cid);
-            });
-            task = readTask(task.task_id);
+            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;
     }
@@ -466,8 +551,13 @@ export class TaskRoomApplicationService {
             });
         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')
+        if (task.state === 'backlog') {
             task = transitionTask(task.task_id);
+            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: `${snapshot.name}@${snapshot.version}`, agents: [] });
+        }
         if (!task.room_id) {
             try {
                 await this.provisionRoom(cfg, task, snapshot, created => {
@@ -478,6 +568,9 @@ export class TaskRoomApplicationService {
             catch (error) {
                 if (error instanceof CoworkUnavailableError)
                     persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                    id: task.task_id, state: readTask(task.task_id).state, category: 'provision_failed',
+                    eventId: task.room_id ? roomFailureEventId(getRoomRecord(task.room_id)) : task.created_at });
                 throw error;
             }
         }
@@ -496,9 +589,23 @@ export class TaskRoomApplicationService {
             catch (error) {
                 if (error instanceof CoworkUnavailableError)
                     persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                    id: task.task_id, state: readTask(task.task_id).state, category: 'provision_failed',
+                    eventId: roomFailureEventId(getRoomRecord(task.room_id)) });
                 throw error;
             }
         }
+        const resultingRoom = getRoomRecord(task.room_id);
+        if (task.state === 'active' && resultingRoom?.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 if (resultingRoom)
+            recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                id: task.task_id, state: task.state, category: 'provision_pending', eventId: roomFailureEventId(resultingRoom) });
         return { task, status: 'ready' };
     }
     createTemplate(cfg, requested, noRoom) {
@@ -544,6 +651,11 @@ export class TaskRoomApplicationService {
             room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
             task_id: task.task_id, template_snapshot: template,
         });
+        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,
+            template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
+            participants: [] });
         onCreated(room);
         room = advanceSaga(room.room_id, 'create_room', 1);
         if (attachOwner) {
@@ -558,18 +670,39 @@ export class TaskRoomApplicationService {
                 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');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room',
+                    id: room.room_id, state: getRoomRecord(room.room_id)?.state ?? 'provisioning',
+                    category: 'provision_failed', eventId: roomFailureEventId(getRoomRecord(room.room_id) ?? room) });
                 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)
+            try {
+                room = 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.task_id ? task.title : task.goal,
+                });
+            }
+            catch (error) {
+                const failed = getRoomRecord(room.room_id) ?? room;
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room', id: failed.room_id,
+                    state: failed.state, category: 'provision_failed', eventId: roomFailureEventId(failed) });
+                throw error;
+            }
+        else
+            room = activateRoom(room.room_id);
+        if (room.state === 'active')
+            recordFleetAuditPresentation({ kind: 'room', operation: 'activate', id: room.room_id,
+                name: room.room_name, previousState: 'provisioning', newState: 'active',
+                revision: room.activated_at ?? room.created_at, taskId: room.task_id,
+                template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
+                participants: roomParticipants(room) });
+        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)
             activateTask(task.task_id);
         return room;
     }

package/dist/briefing.js

@@ -172,16 +172,16 @@ export function generateBriefing(role, v, opts) {
     if (role.session === 'acp') {
         L.push('', '### Managed fleet commands');
         L.push('This ACP role has a supervisor-scoped ours-fleet proxy. Use the ordinary');
-        L.push('`ours-fleet` command; the CLI opens an authenticated audit attempt with your live');
-        L.push('supervisor before parsing or side effects. Your existing OS sandbox remains the executor.');
-        L.push('Every allowed attempt writes a redacted raw invocation and correlated outcome to your');
-        L.push('Owner-visible channel; denied, invalid, failed, and read-only attempts are visible too.');
+        L.push('`ours-fleet` command; the CLI routes public commands through your live supervisor.');
+        L.push('Your existing OS sandbox remains the executor and ordinary CLI validation still applies.');
+        L.push('Reads, help, validation failures, retries, and command invocations are silent in the');
+        L.push('Owner channel. Only confirmed Agent, Task, and Room lifecycle changes are announced.');
         L.push('A minimal call is `ours-fleet spawn DeveloperName --temp`.');
         L.push('For omitted settings, the supervisor inherits your canonical Brain and Role selections,');
         L.push('working directory, neutral permissions, coordinator, and fleet monitor policy. Every');
         L.push('explicit option wins; identity/session-local and secret material never inherit.');
-        L.push('Operator lifecycle/control and hidden worker commands are denied through this route.');
-        L.push('Invocation delivery failure denies execution; outcome uncertainty is reported without retrying effects.');
+        L.push('All public CLI surfaces are available; hidden worker entry points remain internal.');
+        L.push('Lifecycle notice delivery failures stay in service diagnostics and never rerun effects.');
         L.push('This proxy is attribution and convenience, not a security boundary for unisolated roles.');
     }
     if (role.coordinator) {

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.7",
-  "buildId": "a09aa98e92aa",
-  "commit": "d79160ae66847305a109bed339d8c8830a20bba7",
+  "version": "1.1.0-nightly.9",
+  "buildId": "949ece807b97",
+  "commit": "c88941e2850b865432a850db957c806acf10406c",
   "dirty": true,
-  "builtAt": "2026-08-31T07:32:26.852Z",
+  "builtAt": "2026-08-31T09:53:12.340Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -8,6 +8,7 @@ import { createInterface } from 'node:readline';
 import { Command } from 'commander';
 import { VERSION } from './version.js';
 import { INIT_COMPLETION_GUIDANCE } from './init-guidance.js';
+import { bootstrapPresets } from './preset-bootstrap.js';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, runningLabel, } from './provenance.js';
 import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir } from './paths.js';
 import { findRole, loadConfig, ROLE_NAME_RE } from './config.js';
@@ -38,7 +39,7 @@ import { requestWebControl } from './web/control.js';
 import { WebServiceManager } from './web/service.js';
 import { WebAccessStore, passwordAccess, validatePublicOrigin } from './web/access.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
-import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCliExit, recordFleetAuditPresentation, recordFleetAuditResource, } from './fleet-command-audit.js';
+import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCliExit, } from './fleet-command-audit.js';
 import './harness/claude-code.js'; // registers the claude-code adapter
 import './harness/codex.js'; // registers the codex adapter
 import { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './rooms-tasks/cli.js';
@@ -1198,13 +1199,6 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
             if (!response.ok)
                 throw new SessionControlError(response.kind ?? 'backend', response.error ?? 'managed spawn failed');
             const result = response.result;
-            recordFleetAuditResource('agent', result.role);
-            recordFleetAuditPresentation({ kind: 'agent_started', name: result.role,
-                lifetime: result.lifetime, brain: result.brainSummary, role: result.roleSummary,
-                harness: result.harness, session: result.session, model: result.model,
-                permissions: result.permissionMode
-                    ? `${result.permissionMode.fleetMode}/${result.permissionMode.nativeMode}` : undefined,
-                parent: result.caller, actionId: result.creationActionId, inherited: result.inherited });
             const expectedCaller = process.env[FLEET_PROXY_CALLER_ENV];
             if (expectedCaller && result.caller !== expectedCaller)
                 throw new Error(`fleet proxy caller mismatch: expected '${expectedCaller}', got '${result.caller}'`);
@@ -1264,12 +1258,15 @@ cOpt(program.command('doctor').description('prerequisite report'))
     if (!rep.ok)
         throw new FleetCliExit(1);
 });
-program.command('init').description('one-time host setup (units, dirs, linger)')
-    .action(async () => {
+cOpt(program.command('init').description('idempotent host setup plus missing packaged presets'))
+    .action(async (opts) => {
     for (const d of [agentsRoot(), tmpRoot(), logsRoot()])
         mkdirSync(d, { recursive: true });
     for (const m of await pickBackend().init(binPath))
         console.log(m);
+    const seeded = bootstrapPresets(opts.configuration);
+    console.log(`Packaged preset revision ${seeded.revision}: ${seeded.sourceRoot}`);
+    console.log(`Created ${seeded.created.length}; preserved ${seeded.preserved.length} existing file(s).`);
     console.log(INIT_COMPLETION_GUIDANCE);
 });
 const webCommand = cOpt(program.command('web').description('start or open the secure localhost fleet web console'))
@@ -1581,7 +1578,7 @@ async function runFleetCli() {
     const finished = await controlRequest(stateDir, { command: 'fleet_audit_finish', audit: {
             correlationId: attempt.correlationId, class: outcomeClass, exitCode, effect,
             ...(metadata.resourceIds ? { resourceIds: metadata.resourceIds } : {}),
-            ...(metadata.presentation ? { presentation: metadata.presentation } : {}),
+            ...(metadata.presentations ? { presentations: metadata.presentations } : {}),
         } });
     if (!finished.ok)
         throw new SessionControlError(finished.kind ?? 'backend', finished.error ?? `audit delivery failed after execution; effect status=${effect}`);

package/dist/config-yaml.d.ts

@@ -1,5 +1,5 @@
 export type YamlMode = 'compat' | 'strict';
-export type ConfigDiagnosticKind = 'anchor' | 'alias' | 'explicit-tag' | 'non-scalar-key' | 'multiple-documents';
+export type ConfigDiagnosticKind = 'anchor' | 'alias' | 'explicit-tag' | 'non-scalar-key' | 'multiple-documents' | 'deprecated-field';
 export interface ConfigDiagnostic {
     severity: 'warning';
     kind: ConfigDiagnosticKind;

package/dist/config.d.ts

@@ -220,7 +220,7 @@ export interface FleetConfig {
     files: string[];
     configMode?: 'split-v2';
     sourceDocuments?: Array<{
-        kind: 'Manifest' | 'Agent' | 'Role' | 'Brain';
+        kind: 'Manifest' | 'Agent' | 'Role' | 'Brain' | 'RoomTemplate';
         id?: string;
         path: string;
     }>;

package/dist/config.js

@@ -265,6 +265,35 @@ function readKindDirectory(root, kind, required, yamlMode, diagnostics, files) {
     }
     return result;
 }
+function readRoomTemplateDirectory(root, yamlMode, diagnostics, files) {
+    if (!existsSync(root))
+        return {};
+    assertTrustedPath(root, 'directory');
+    const result = {};
+    const sources = new Map();
+    const names = readdirSync(root)
+        .filter(name => ['.yaml', '.yml'].includes(extname(name).toLowerCase())).sort();
+    for (const filename of names) {
+        const file = join(root, filename);
+        assertTrustedPath(file, 'file');
+        const id = basename(filename, extname(filename));
+        const previous = sources.get(id);
+        if (previous)
+            throw new ConfigError(`E_DUPLICATE_ID: room template '${id}' defined by both ${previous} and ${file}`);
+        const parsed = parseFleetDocument(file, readFileSync(file, 'utf8'), yamlMode);
+        diagnostics.push(...parsed.diagnostics);
+        if (parsed.value.override_builtin === true)
+            diagnostics.push({
+                severity: 'warning', kind: 'deprecated-field', file, line: 1, column: 1,
+                message: `${file}: override_builtin is deprecated and ignored for a file-backed Room template`,
+            });
+        files.push(file);
+        const validated = validateRoomTemplatesConfig({ [id]: parsed.value }, file)[id];
+        result[id] = { ...validated, sourceFile: file };
+        sources.set(id, file);
+    }
+    return result;
+}
 function selection(raw, kind, agentFile, presets, allowed) {
     if (!isPlainObject(raw))
         schemaError(agentFile, `/${kind}`, 'must be { ref } or { inline }');
@@ -586,6 +615,9 @@ export function loadConfig(configPath, options = {}) {
     let ownerInvite;
     let roomTemplates;
     let tasks;
+    const fileTemplates = readRoomTemplateDirectory(join(splitRootFor(base), 'room_templates'), options.yamlMode ?? 'compat', diagnostics, files);
+    if (Object.keys(fileTemplates).length)
+        roomTemplates = fileTemplates;
     for (const { file, doc } of docs) {
         if (doc.rooms !== undefined) {
             if (rooms)
@@ -598,7 +630,21 @@ export function loadConfig(configPath, options = {}) {
         }
         if (doc.room_templates !== undefined) {
             const validated = validateRoomTemplatesConfig(deepSub(doc.room_templates, vars), file);
-            roomTemplates = { ...(roomTemplates ?? {}), ...validated };
+            const raw = doc.room_templates;
+            for (const [name, template] of Object.entries(validated)) {
+                const shadowed = roomTemplates?.[name];
+                const marker = raw[name]?.override_builtin;
+                if (shadowed && (marker !== true || template.version <= shadowed.version))
+                    throw new ConfigError(`${file}: room_templates.${name} shadows file preset ${shadowed.sourceFile}; `
+                        + 'set override_builtin: true and use a higher version');
+                if (marker === true)
+                    diagnostics.push({
+                        severity: 'warning', kind: 'deprecated-field', file, line: 1, column: 1,
+                        message: `${file}: room_templates.${name}.override_builtin is deprecated; `
+                            + 'it is retained only as an explicit manifest-over-file migration marker',
+                    });
+                roomTemplates = { ...(roomTemplates ?? {}), [name]: { ...template, sourceFile: file } };
+            }
         }
         if (doc.tasks !== undefined) {
             if (tasks)
@@ -616,7 +662,8 @@ export function loadConfig(configPath, options = {}) {
                 return { kind: 'Manifest', path };
             const parent = basename(dirname(path));
             const kind = parent === 'agents' ? 'Agent'
-                : parent === 'roles' ? 'Role' : 'Brain';
+                : parent === 'roles' ? 'Role'
+                    : parent === 'room_templates' ? 'RoomTemplate' : 'Brain';
             return { kind, id: basename(path, extname(path)), path };
         }),
     };