@ours.network/fleet 1.2.0-nightly.4 → 1.2.0-nightly.41

package/dist/application/conversation-history.d.ts

@@ -0,0 +1,25 @@
+import type { ConversationEventV1 } from '../session/conversation-types.js';
+import type { ConversationPageView } from './session-control.js';
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export declare function conversationEventVisible(event: ConversationEventV1, sessionGeneration: string, resumedSessionId?: string): boolean;
+export interface ConversationTailPage extends ConversationPageView {
+    /** Pass as `before` to read the next older page. */
+    olderCursor?: string;
+    hasOlder: boolean;
+    /** Latest page only: older events the view still needs, the current session's latest capabilities and still-pending permission requests. */
+    context: ConversationEventV1[];
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export declare function conversationTailPage(stateDir: string, request: {
+    before?: string;
+    limit?: number;
+}, snapshot: ConversationPageView['snapshot'], resumedSessionId?: string): Promise<ConversationTailPage>;
+/** Read the existing ACP session ledger without opening its writer/recovery store. */
+export declare function resumedConversationPage(stateDir: string, request: {
+    after?: string;
+    limit?: number;
+}, live: ConversationPageView, expectedSessionId: string): Promise<ConversationPageView>;

package/dist/application/conversation-history.js

@@ -0,0 +1,189 @@
+import { createReadStream } from 'node:fs';
+import { open, readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+const HISTORICAL_KINDS = ['fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export function conversationEventVisible(event, sessionGeneration, resumedSessionId) {
+    return event.source !== 'agent_replay' && (event.sessionGeneration === sessionGeneration || (!!resumedSessionId && HISTORICAL_KINDS.includes(event.kind) && event.acpSessionId === resumedSessionId));
+}
+/** Newest-first lines of a file, read in chunks from its end; `visit` returns false to stop. */
+async function readLinesBackward(path, visit) {
+    const file = await open(path, 'r');
+    try {
+        let position = (await file.stat()).size;
+        let carry = Buffer.alloc(0);
+        while (position > 0) {
+            const size = Math.min(256 * 1024, position);
+            position -= size;
+            const chunk = Buffer.alloc(size);
+            await file.read(chunk, 0, size, position);
+            let buffer = Buffer.concat([chunk, carry]);
+            let end = buffer.length;
+            for (let i = buffer.length - 1; i >= 0; i--) {
+                if (buffer[i] !== 10)
+                    continue;
+                if (end > i + 1 && !visit(buffer.toString('utf8', i + 1, end)))
+                    return false;
+                end = i;
+            }
+            carry = buffer.subarray(0, end);
+        }
+        if (carry.length && !visit(carry.toString('utf8')))
+            return false;
+        return true;
+    }
+    finally {
+        await file.close();
+    }
+}
+/** The last event cursor in a segment, read from its tail; undefined when none is readable. */
+async function lastSeq(path) {
+    let seq;
+    await readLinesBackward(path, line => { try {
+        const value = Number(JSON.parse(line).seq);
+        if (Number.isSafeInteger(value)) {
+            seq = value;
+            return false;
+        }
+    }
+    catch { } return true; });
+    return seq;
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export async function conversationTailPage(stateDir, request, snapshot, resumedSessionId) {
+    const before = request.before === undefined ? Infinity : Number(request.before);
+    if (before !== Infinity && (!Number.isSafeInteger(before) || before < 0))
+        throw new Error('before must be a ledger cursor');
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    let files = [];
+    try {
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort().reverse();
+    }
+    catch { }
+    const events = [];
+    let newest;
+    let hasOlder = false;
+    const pending = new Set(snapshot.pendingPermissionIds);
+    let capabilities;
+    const context = [];
+    // Context only accompanies the newest page; older pages stop as soon as they are full.
+    const wantsContext = () => before === Infinity && (!capabilities || pending.size > 0);
+    const generation = `"sessionGeneration":${JSON.stringify(snapshot.sessionGeneration)}`;
+    for (const file of files) {
+        const more = await readLinesBackward(join(stateDir, '.conversation', file), line => {
+            if (hasOlder) {
+                // The page is full; only the current generation's context kinds matter. Generations are
+                // appended in order, so the first line of an older one ends the search.
+                if (!line.includes(generation))
+                    return !line.includes('"sessionGeneration":') && wantsContext();
+                if (!line.includes('"capabilities.updated"') && !line.includes('"permission.requested"'))
+                    return wantsContext();
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return true;
+            }
+            const seq = Number(event.seq);
+            if (!Number.isSafeInteger(seq))
+                return true;
+            newest ??= seq;
+            if (seq < before && conversationEventVisible(event, snapshot.sessionGeneration, resumedSessionId)) {
+                const inPage = !hasOlder && events.length < limit;
+                if (event.sessionGeneration === snapshot.sessionGeneration) {
+                    if (event.kind === 'capabilities.updated' && !capabilities) {
+                        capabilities = event;
+                        if (!inPage)
+                            context.push(event);
+                    }
+                    if (event.kind === 'permission.requested' && event.permissionId && pending.delete(event.permissionId) && !inPage)
+                        context.push(event);
+                }
+                if (inPage)
+                    events.push(event);
+                else
+                    hasOlder = true;
+            }
+            return !hasOlder || wantsContext();
+        });
+        if (!more)
+            break;
+    }
+    events.reverse();
+    context.reverse();
+    return { events, snapshot, hasOlder, context, hasMore: false,
+        ...(events.length ? { olderCursor: String(events[0].seq) } : {}),
+        ...(before === Infinity && newest !== undefined ? { nextCursor: String(newest) } : {}) };
+}
+/** Read the existing ACP session ledger without opening its writer/recovery store. */
+export async function resumedConversationPage(stateDir, request, live, expectedSessionId) {
+    let sessionId;
+    let files;
+    try {
+        sessionId = (await readFile(join(stateDir, '.acp-session-id'), 'utf8')).trim();
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort();
+    }
+    catch {
+        return live;
+    }
+    if (!sessionId || sessionId !== expectedSessionId || !files.length)
+        return live;
+    const after = Number(request.after ?? 0);
+    if (!Number.isSafeInteger(after) || after < 0)
+        return live;
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    const events = [];
+    let next = String(after);
+    let first;
+    let hasMore = false;
+    scan: for (const file of files) {
+        // Forward polling asks for the newest few events: skip whole segments that end at or before the cursor.
+        const end = await lastSeq(join(stateDir, '.conversation', file));
+        if (end !== undefined && end <= after)
+            continue;
+        const input = createReadStream(join(stateDir, '.conversation', file), { encoding: 'utf8' });
+        const lines = createInterface({ input, crlfDelay: Infinity });
+        try {
+            for await (const line of lines) {
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const cursor = Number(event.seq);
+                if (!Number.isSafeInteger(cursor) || cursor <= after)
+                    continue;
+                const historical = ['fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'].includes(event.kind);
+                const visible = event.source !== 'agent_replay' && (event.sessionGeneration === live.snapshot.sessionGeneration || (historical && event.acpSessionId === sessionId));
+                if (!visible) {
+                    next = String(cursor);
+                    continue;
+                }
+                if (events.length === limit) {
+                    hasMore = true;
+                    break scan;
+                }
+                first ??= String(cursor);
+                events.push(event);
+                next = String(cursor);
+            }
+        }
+        finally {
+            lines.close();
+            input.destroy();
+        }
+    }
+    // If a fresh/resumed session changed during the read, use the live page only.
+    if ((await readFile(join(stateDir, '.acp-session-id'), 'utf8')).trim() !== sessionId)
+        return live;
+    return { ...live, events, firstAvailableCursor: first, nextCursor: next, hasMore };
+}

package/dist/application/fleet-query-service.d.ts

@@ -24,7 +24,7 @@ export declare class FleetQueryService {
     private readonly options;
     private readonly control;
     constructor(options: FleetQueryOptions);
-    list(): Promise<Array<{
+    list(includeTemporary?: boolean): Promise<Array<{
         role: RoleRecord;
         status: RoleStatus;
         capabilities: RoleCapabilities;

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

@@ -75,9 +75,9 @@ export class FleetQueryService {
         this.options = options;
         this.control = options.control ?? controlRequest;
     }
-    async list() {
+    async list(includeTemporary = false) {
         const roles = (await this.options.repository.list())
-            .filter(role => role.configured && role.lifetime === 'permanent');
+            .filter(role => (role.configured && role.lifetime === 'permanent') || (includeTemporary && role.lifetime === 'temporary'));
         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/legacy-supervisor-identity.d.ts

@@ -0,0 +1,7 @@
+/** Read-only compatibility proof for supervisors predating descriptor identity metadata. */
+export declare function legacySupervisorIdentity(role: string, name: string, temporary: boolean, generation: number): {
+    name: string;
+    cid: string;
+    generation: number;
+    proof: string;
+};

package/dist/application/legacy-supervisor-identity.js

@@ -0,0 +1,43 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { stateRoot } from '../paths.js';
+import { binderKey } from '../agent-ours/state.js';
+import { FleetError } from './errors.js';
+/** Read-only compatibility proof for supervisors predating descriptor identity metadata. */
+export function legacySupervisorIdentity(role, name, temporary, generation) {
+    const root = join(stateRoot(), 'private-ours');
+    try {
+        const matches = [];
+        for (const entry of readdirSync(root, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !/^[a-f0-9]{64}$/.test(entry.name))
+                continue;
+            const dir = join(root, entry.name);
+            const instance = JSON.parse(readFileSync(join(dir, 'instance.json'), 'utf8'));
+            if (instance.role !== role)
+                continue;
+            const state = JSON.parse(readFileSync(join(dir, 'state.json'), 'utf8'));
+            const pin = JSON.parse(readFileSync(join(dir, 'identity-pin.json'), 'utf8'));
+            if (!Number.isSafeInteger(generation) || generation < 1
+                || typeof state.action !== 'string' || !state.action
+                || instance.temporary !== temporary || typeof instance.instance !== 'string' || !instance.instance
+                || state.version !== 1 || state.instance !== instance.instance
+                || state.name !== name || state.lifetime !== (temporary ? 'temporary' : 'permanent')
+                || state.generation !== generation || !['READY', 'SERVING'].includes(state.phase)
+                || typeof state.daemon !== 'string' || !state.daemon || binderKey(state.daemon, name) !== entry.name
+                || !/^[a-f0-9]{64}$/i.test(state.cid ?? '')
+                || pin.daemon !== state.daemon || pin.name !== name || pin.cid !== state.cid)
+                throw new Error('mismatched legacy ownership proof');
+            matches.push({ name, cid: state.cid, generation, proof: createHash('sha256').update(JSON.stringify([
+                    instance.instance, state.action, state.daemon, name, state.cid, state.lifetime, generation,
+                ])).digest('hex') });
+        }
+        if (matches.length !== 1)
+            throw new Error('missing or ambiguous legacy ownership proof');
+        return matches[0];
+    }
+    catch {
+        // The private directory also contains ownership material: never echo parse errors.
+        throw new FleetError('capability_unavailable', 'legacy supervisor ownership proof is missing, ambiguous, or mismatched');
+    }
+}

package/dist/application/model-catalog.d.ts

@@ -14,7 +14,7 @@ export interface HarnessModelCatalog {
 export declare function codexModelCatalog(path?: string): HarnessModelCatalog;
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export declare function claudeModelCatalog(): HarnessModelCatalog;

package/dist/application/model-catalog.js

@@ -41,17 +41,20 @@ export function codexModelCatalog(path = join(homedir(), '.codex', 'models_cache
 }
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export function claudeModelCatalog() {
     const reasoningEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
     return {
         models: [
+            { id: 'claude-fable-5-1', label: 'Claude Fable 5.1', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-opus-5-5', label: 'Claude Opus 5.5', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', reasoningEfforts: [], source: 'claude-adapter-2.1' },
             { id: 'claude-fable-5', label: 'Claude Fable 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-opus-5', label: 'Claude Opus 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-sonnet-5', label: 'Claude Sonnet 5', reasoningEfforts, source: 'claude-adapter-2.1' },
         ],
-        warnings: ['Claude Code exposes no typed model-list endpoint; choices are exact 2.1 adapter IDs and entitlement is validated at launch.'],
+        warnings: ['Claude Code exposes no typed model-list endpoint; choices require a current Claude runtime (verified with 2.1.281); older bundled SDKs need CLAUDE_CODE_EXECUTABLE. Entitlement is validated at launch.'],
     };
 }

package/dist/application/preset-provenance.d.ts

@@ -0,0 +1,19 @@
+export declare const PROVENANCE_KINDS: {
+    readonly role: "roles";
+    readonly brain: "brains";
+    readonly template: "agent_templates";
+    readonly layout: "room_layouts";
+};
+export type ProvenanceKind = keyof typeof PROVENANCE_KINDS;
+export type ProvenanceStatus = 'predefined' | 'changed' | 'custom';
+export interface ProvenanceEntry {
+    status: ProvenanceStatus;
+    preset?: string;
+}
+export type Provenance = Record<ProvenanceKind, Record<string, ProvenanceEntry>>;
+export declare class PresetProvenance {
+    private configPath?;
+    private presetRoot;
+    constructor(configPath?: string | undefined, presetRoot?: string);
+    read(): Provenance;
+}

package/dist/application/preset-provenance.js

@@ -0,0 +1,59 @@
+/** Where each configured definition came from, compared with the packaged presets.
+ * A definition is `predefined` when it has the same value as the shipped preset of
+ * the same name, `changed` when a preset of that name exists but the value differs,
+ * and `custom` otherwise. Values are compared after parsing, so the formatting the
+ * configuration editor writes does not count as a change. Preset text is returned
+ * so users can see exactly what ships; it contains no host data.
+ */
+import { isDeepStrictEqual } from 'node:util';
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { parse } from 'yaml';
+import { defaultConfigPath } from '../paths.js';
+import { splitRootFor } from '../config.js';
+import { packagedPresetRoot } from '../preset-bootstrap.js';
+export const PROVENANCE_KINDS = { role: 'roles', brain: 'brains', template: 'agent_templates', layout: 'room_layouts' };
+const MAX_BYTES = 256 * 1024;
+/** Regular, bounded YAML files of one directory, by definition name. Anything else is skipped. */
+function yamlFiles(dir) {
+    const files = new Map();
+    if (!existsSync(dir) || !lstatSync(dir).isDirectory())
+        return files;
+    for (const file of readdirSync(dir).sort()) {
+        if (!/\.ya?ml$/.test(file))
+            continue;
+        const path = join(dir, file), stat = lstatSync(path);
+        if (!stat.isFile() || stat.size > MAX_BYTES)
+            continue;
+        files.set(basename(file, extname(file)), readFileSync(path, 'utf8'));
+    }
+    return files;
+}
+const parsed = (text) => { try {
+    return parse(text);
+}
+catch {
+    return Symbol('unparseable');
+} };
+export class PresetProvenance {
+    configPath;
+    presetRoot;
+    constructor(configPath, presetRoot = join(packagedPresetRoot(), 'fleet')) {
+        this.configPath = configPath;
+        this.presetRoot = presetRoot;
+    }
+    read() {
+        const split = splitRootFor(this.configPath ?? defaultConfigPath());
+        const result = {};
+        for (const [kind, dir] of Object.entries(PROVENANCE_KINDS)) {
+            const presets = yamlFiles(join(this.presetRoot, dir)), installed = yamlFiles(join(split, dir));
+            result[kind] = Object.fromEntries([...installed].map(([name, text]) => {
+                const preset = presets.get(name);
+                if (preset === undefined)
+                    return [name, { status: 'custom' }];
+                return [name, { status: isDeepStrictEqual(parsed(text), parsed(preset)) ? 'predefined' : 'changed', preset }];
+            }));
+        }
+        return result;
+    }
+}

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

@@ -138,7 +138,7 @@ export class RoleCreationService {
             reasoningEffort: resolved.effort,
             cwd, lifetime: request.lifetime,
             permissions: resolvePermissions(defaults.permissions, request.permissions),
-            monitor: resolveMonitorConfig(defaults.monitor, request.monitor),
+            monitor: resolveMonitorConfig(defaults.monitor, request.monitor, { harness: resolved.harness }),
         };
         const warnings = [];
         if (request.permissions.approval === 'allow')

package/dist/application/role-repository.js

@@ -1,7 +1,7 @@
 import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { parse } from 'yaml';
-import { loadConfig, resolveMonitorConfig, resolvePermissions, ROLE_NAME_RE, } from '../config.js';
+import { loadConfig, resolveSnapshotMonitor, resolvePermissions, ROLE_NAME_RE, } from '../config.js';
 import { agentsRoot, tmpRoot } from '../paths.js';
 import { readSpawnLineage } from '../web/topology.js';
 const MAX_SNAPSHOT_BYTES = 256 * 1024;
@@ -54,7 +54,7 @@ function snapshot(path, name) {
                 session, identity: typeof raw.identity === 'string' ? raw.identity : name,
                 permissions: resolvePermissions(undefined, raw.permissions),
                 permissionsDeclared: raw.permissions !== undefined,
-                monitor: resolveMonitorConfig(undefined, raw.monitor),
+                monitor: resolveSnapshotMonitor(raw.monitor),
                 sourceFile: '(temp)',
             },
         };

package/dist/application/room-layout-definitions.d.ts

@@ -0,0 +1,45 @@
+import { loadConfig } from '../config.js';
+import { type RoomLayoutDefinition } from '../rooms-tasks/layout-config.js';
+export declare const ABSENT_REVISION = "absent";
+export type LayoutDefinitionBody = Omit<RoomLayoutDefinition, 'sourceFile'>;
+export type LayoutListEntry = {
+    name: string;
+    revision: string;
+    file: string;
+    definition: LayoutDefinitionBody;
+    issues: string[];
+    definition_hash: string;
+} | {
+    name: string;
+    revision: string;
+    file: string;
+    error: string;
+};
+export declare class RoomLayoutDefinitions {
+    private configPath?;
+    private deps;
+    constructor(configPath?: string | undefined, deps?: {
+        loadConfiguration?: typeof loadConfig;
+    });
+    private root;
+    private pathFor;
+    private currentRevision;
+    /** Agent-template references that do not resolve in the current Fleet configuration. */
+    private templateIssues;
+    /** The configured default (`rooms.defaults.template`, else `tasks.default_room_template`) when it names a usable layout. */
+    defaultLayout(entries?: LayoutListEntry[]): string | undefined;
+    list(): LayoutListEntry[];
+    validate(raw: unknown): {
+        definition?: LayoutDefinitionBody;
+        issues: string[];
+    };
+    save(name: string, expectedRevision: string, raw: unknown): Promise<{
+        name: string;
+        revision: string;
+        definition: LayoutDefinitionBody;
+    }>;
+    remove(name: string, expectedRevision: string): Promise<{
+        name: string;
+        deleted: boolean;
+    }>;
+}

package/dist/application/room-layout-definitions.js

@@ -0,0 +1,130 @@
+/** Web authoring of `fleet/room_layouts/<name>.yaml`.
+ * Writes are revision-guarded (sha256 of the file bytes) and validated with the
+ * same parser the CLI uses. Retained layout runs keep their own snapshots, so
+ * editing or deleting a definition never changes an existing run.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { stringify } from 'yaml';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { parseFleetDocument } from '../config-yaml.js';
+import { defaultConfigPath } from '../paths.js';
+import { loadConfig, splitRootFor } from '../config.js';
+import { assertLayoutFile, validLayoutKey, validateRoomLayout } from '../rooms-tasks/layout-config.js';
+import { FleetError } from './errors.js';
+import { layoutDefinitionHash } from './task-layouts.js';
+export const ABSENT_REVISION = 'absent';
+const revisionOf = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export class RoomLayoutDefinitions {
+    configPath;
+    deps;
+    constructor(configPath, deps = {}) {
+        this.configPath = configPath;
+        this.deps = deps;
+    }
+    root() { return join(splitRootFor(this.configPath ?? defaultConfigPath()), 'room_layouts'); }
+    pathFor(name) {
+        if (!validLayoutKey(name))
+            throw new FleetError('invalid_request', 'layout name must start with a letter and use letters, digits, - or _');
+        return join(this.root(), `${name}.yaml`);
+    }
+    currentRevision(path) {
+        if (!existsSync(path))
+            return ABSENT_REVISION;
+        assertLayoutFile(path);
+        return revisionOf(readFileSync(path));
+    }
+    /** Agent-template references that do not resolve in the current Fleet configuration. */
+    templateIssues(definition) {
+        let templates = {};
+        try {
+            templates = (this.deps.loadConfiguration ?? loadConfig)(this.configPath).agentTemplates ?? {};
+        }
+        catch (error) {
+            return [`fleet configuration unavailable: ${error.message}`];
+        }
+        return Object.entries(definition.participants).flatMap(([key, participant]) => participant.agent_template && !Object.hasOwn(templates, participant.agent_template)
+            ? [`participant ${key}: agent template not found: ${participant.agent_template}`] : []);
+    }
+    /** The configured default (`rooms.defaults.template`, else `tasks.default_room_template`) when it names a usable layout. */
+    defaultLayout(entries = this.list()) {
+        let name;
+        try {
+            const config = (this.deps.loadConfiguration ?? loadConfig)(this.configPath);
+            name = config.rooms?.defaults?.template ?? config.tasks?.default_room_template;
+        }
+        catch {
+            return undefined;
+        }
+        const entry = entries.find(e => e.name === name);
+        return entry && !('error' in entry) && !entry.issues.length ? entry.name : undefined;
+    }
+    list() {
+        const root = this.root();
+        if (!existsSync(root))
+            return [];
+        assertLayoutFile(root, true);
+        return readdirSync(root).filter(file => /\.ya?ml$/.test(file)).sort().map(file => {
+            const name = basename(file, extname(file)), path = join(root, file);
+            try {
+                if (!validLayoutKey(name))
+                    throw Error(`invalid room layout id: ${name}`);
+                assertLayoutFile(path);
+                const bytes = readFileSync(path);
+                const definition = validateRoomLayout(parseFleetDocument(path, bytes.toString('utf8'), 'strict').value, file);
+                return { name, file, revision: revisionOf(bytes), definition, issues: this.templateIssues(definition), definition_hash: layoutDefinitionHash(definition) };
+            }
+            catch (error) {
+                // Only a trusted regular file may be read to offer an overwrite revision.
+                let revision = ABSENT_REVISION;
+                try {
+                    assertLayoutFile(path);
+                    revision = revisionOf(readFileSync(path));
+                }
+                catch { /* not trusted: never read */ }
+                return { name, file, revision, error: error.message };
+            }
+        });
+    }
+    validate(raw) {
+        let definition;
+        try {
+            definition = validateRoomLayout(raw, 'room layout');
+        }
+        catch (error) {
+            return { issues: [error.message] };
+        }
+        return { definition, issues: this.templateIssues(definition) };
+    }
+    async save(name, expectedRevision, raw) {
+        const path = this.pathFor(name);
+        const { definition, issues } = this.validate(raw);
+        if (!definition || issues.length)
+            throw new FleetError('invalid_request', issues.join('; '));
+        const root = this.root();
+        mkdirSync(root, { recursive: true, mode: 0o700 });
+        assertLayoutFile(root, true);
+        return withFileLock(`${path}.lock`, async () => {
+            const current = this.currentRevision(path);
+            if (current !== expectedRevision)
+                throw new FleetError('stale_state', 'room layout changed since it was loaded; reload before saving');
+            const { description, participants, rooms } = definition;
+            const text = stringify({ version: 1, ...(description ? { description } : {}), participants, rooms });
+            replaceFileAtomically(path, text, 0o600);
+            return { name, revision: revisionOf(text), definition };
+        });
+    }
+    async remove(name, expectedRevision) {
+        const path = this.pathFor(name);
+        return withFileLock(`${path}.lock`, async () => {
+            const current = this.currentRevision(path);
+            if (current === ABSENT_REVISION)
+                return { name, deleted: false };
+            if (current !== expectedRevision)
+                throw new FleetError('stale_state', 'room layout changed since it was loaded; reload before deleting');
+            unlinkSync(path);
+            return { name, deleted: true };
+        });
+    }
+}