@ours.network/fleet 1.2.0-nightly.9 → 2.0.1

package/dist/application/resource-observer.js

@@ -0,0 +1,323 @@
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+import { lstatSync, statSync, readdirSync, watch } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { splitRootFor } from '../config.js';
+import { agentsRoot, tmpRoot, stateRoot, defaultConfigPath } from '../paths.js';
+// Directory discovery is shared by payload and notification owners. Each owner
+// has its own lifetime/coverage; the underlying OS watch is reference counted.
+const sharedWatches = new Map();
+function sharedWatch(path, listener) {
+    const key = `${path}:${identity(path, true)}`;
+    let entry = sharedWatches.get(key);
+    if (!entry) {
+        const clients = new Set(), listeners = new Map();
+        const handle = watch(path, { persistent: false }, (event, name) => { for (const fn of [...listeners.values()])
+            fn(event, name); });
+        entry = { handle, clients, listeners };
+        sharedWatches.set(key, entry);
+        handle.on('error', error => { for (const client of [...clients])
+            client.emit('error', error); });
+        handle.on('close', () => { for (const client of [...clients])
+            client.emit('close'); });
+    }
+    const current = entry, client = new EventEmitter();
+    let closed = false;
+    current.clients.add(client);
+    current.listeners.set(client, listener);
+    return Object.assign(client, { close() {
+            if (closed)
+                return;
+            closed = true;
+            current.clients.delete(client);
+            current.listeners.delete(client);
+            if (!current.clients.size) {
+                sharedWatches.delete(key);
+                current.handle.close();
+            }
+        } });
+}
+const commits = new Set();
+/** Only call after durable persistence succeeds. Observers cannot fail a commit. */
+export function publishFleetResourceCommit(path) {
+    for (const listener of [...commits]) {
+        try {
+            listener(resolve(path));
+        }
+        catch { }
+    }
+}
+function directoryGone(error) {
+    return ['ENOENT', 'ENOTDIR'].includes(error.code ?? '');
+}
+function identity(path, followLink = false) {
+    try {
+        const value = followLink ? statSync(path) : lstatSync(path);
+        if (value.isSymbolicLink())
+            throw Error('symbolic resource directory');
+        return value.isDirectory() ? `${value.dev}:${value.ino}:${value.birthtimeMs}` : undefined;
+    }
+    catch (error) {
+        if (directoryGone(error))
+            return;
+        throw error;
+    }
+}
+function within(path, root) { return path === root || path.startsWith(root + sep); }
+/** Lock directories and the claim/reclaim entries derived from their names
+ * (`<lock>.claim.<pid>.<uuid>`, `<lock>.reclaim`) are never resources. */
+const lockClaim = /\.claim\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$|\.reclaim$/;
+function lockName(name) { return name === '.locks' || name.endsWith('.lock'); }
+function lockArtifact(name) { return lockName(name) || (lockClaim.test(name) && lockName(name.replace(lockClaim, ''))); }
+/** Full discovery is synchronous and lstats every covered directory. Wakes are
+ * still delivered promptly, but discovery runs at most once per window. */
+const DISCOVERY_WINDOW_MS = 100;
+/** Native notifications cover supported local mounts. No idle content scan or
+ * silent claim of coverage after watch failure. Parents survive atomic rename.
+ * Discovery reads directory metadata only, never opens a controller or transcript. */
+export function observeFleetResources(scope, onCommitted, signal) {
+    const config = resolve(scope.configPath ?? defaultConfigPath());
+    const roots = (scope.roots ?? [agentsRoot(), tmpRoot()]).map(p => resolve(p));
+    const paths = (scope.paths ?? (scope.roots && !scope.configPath ? roots : [...roots, splitRootFor(config), join(stateRoot(), 'tasks'), join(stateRoot(), 'rooms'), join(stateRoot(), 'watchdogs'), join(stateRoot(), 'layouts'), join(stateRoot(), 'member-additions'), join(stateRoot(), 'subscriptions')])).map(p => resolve(p));
+    // Explicit roots without config select discovery only (notification producers).
+    const configEnabled = scope.configPath !== undefined || (!scope.paths && !scope.roots);
+    const adoptedHomes = configEnabled ? [join(homedir(), '.claude'), join(homedir(), '.codex')] : [];
+    if (configEnabled)
+        paths.push(dirname(config), resolve(stateRoot()), ...adoptedHomes);
+    // Explicit resource locations and their ancestors already belong to the
+    // caller's read scope (e.g. /home -> /var/home or a linked state root).
+    // Discovered descendants keep lstat validation and never traverse child links.
+    const trustedPaths = new Set(paths);
+    for (const path of paths) {
+        let parent = path;
+        for (let depth = 0; depth < 4 && dirname(parent) !== parent; depth++, parent = dirname(parent))
+            trustedPaths.add(parent);
+    }
+    const resourceIdentity = (path) => identity(path, trustedPaths.has(path));
+    const locks = resolve(stateRoot(), 'locks');
+    const ignored = (path) => within(path, locks) || path.split(sep).some(name => lockArtifact(name) || name.endsWith('.tmp'));
+    let state = { protocolVersion: 1, producerGeneration: randomUUID(), position: 0, health: 'healthy' };
+    let disposed = signal.aborted, queued = false, discoveredAt = -Infinity;
+    let recovery, discovery;
+    let installing = false, installFailure;
+    const cursors = new Set();
+    const watchers = new Map();
+    const release = () => { const old = [...watchers.values()]; watchers.clear(); for (const entry of old)
+        entry.handle.close(); };
+    const fail = (error) => {
+        if (installing) {
+            installFailure = error;
+            return;
+        }
+        if (disposed || state.health !== 'healthy')
+            return;
+        state = { ...state, position: state.position + 1, health: ['ENOSYS', 'ENOTSUP', 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM'].includes(error.code ?? '') ? 'unsupported' : 'failed' };
+        release();
+        onCommitted({ ...state });
+        recover();
+    };
+    const install = () => {
+        installing = true;
+        installFailure = undefined;
+        let added = 0;
+        try {
+            const wanted = new Set();
+            const cover = (dir) => {
+                const id = resourceIdentity(dir);
+                if (!id)
+                    return;
+                wanted.add(dir);
+                const existing = watchers.get(dir);
+                if (existing && existing.identity === id)
+                    return;
+                if (existing) {
+                    watchers.delete(dir);
+                    existing.handle.close();
+                }
+                let handle;
+                try {
+                    handle = (scope.watch ?? sharedWatch)(dir, (_event, filename) => {
+                        if (watchers.get(dir)?.handle !== handle)
+                            return;
+                        // Ignore sibling noise from ancestor coverage, lock churn and delivery acknowledgements.
+                        const changed = filename === null ? dir : resolve(dir, String(filename));
+                        if (ignored(changed))
+                            return;
+                        if (paths.some(path => within(changed, path) || within(path, changed)) || (configEnabled && changed === config) || filename === null)
+                            wake(filename === null ? undefined : changed);
+                    });
+                }
+                catch (error) {
+                    // Parent coverage owns removal/recreation. Only verified disappearance
+                    // is benign; permissions, unsupported watches and other errors fail.
+                    if (directoryGone(error) && !resourceIdentity(dir))
+                        return;
+                    throw error;
+                }
+                watchers.set(dir, { identity: id, handle });
+                added++;
+                handle.on('error', (error) => { if (watchers.get(dir)?.handle === handle)
+                    fail(error); });
+                handle.on('close', () => { if (watchers.get(dir)?.handle === handle)
+                    fail(Error('resource watch closed')); });
+                if (installFailure)
+                    throw installFailure;
+            };
+            const visit = (dir, depth) => {
+                if (within(dir, locks))
+                    return;
+                const id = resourceIdentity(dir);
+                if (!id)
+                    return;
+                // Watch before enumerating children: creation before watch is covered by
+                // this scan; creation after watch schedules another discovery pass.
+                cover(dir);
+                if (!depth)
+                    return;
+                let entries;
+                try {
+                    entries = readdirSync(dir, { withFileTypes: true });
+                }
+                catch (error) {
+                    if (directoryGone(error) && !resourceIdentity(dir))
+                        return;
+                    throw error;
+                }
+                for (const entry of entries) {
+                    if (!entry.isDirectory() || entry.isSymbolicLink() || lockArtifact(entry.name))
+                        continue;
+                    visit(join(dir, entry.name), depth - 1);
+                }
+            };
+            for (const path of paths) {
+                // Enough ancestors to retain the subscription when its state root is replaced.
+                let parent = path;
+                for (let depth = 0; depth < 4 && dirname(parent) !== parent; depth++, parent = dirname(parent)) {
+                    if (resourceIdentity(parent)) {
+                        wanted.add(parent);
+                        cover(parent);
+                    }
+                }
+                visit(path, configEnabled && (path === dirname(config) || adoptedHomes.includes(path)) ? 0 : 3);
+            }
+            for (const [dir, entry] of watchers) {
+                if (!wanted.has(dir) || resourceIdentity(dir) !== entry.identity) {
+                    watchers.delete(dir);
+                    entry.handle.close();
+                }
+            }
+            if (installFailure)
+                throw installFailure;
+            return added;
+        }
+        finally {
+            installing = false;
+        }
+    };
+    const recover = () => {
+        if (disposed || state.health === 'healthy' || !scope.retryWatchFailures || recovery)
+            return;
+        recovery = setTimeout(() => {
+            recovery = undefined;
+            if (disposed)
+                return;
+            try {
+                install();
+            }
+            catch {
+                release();
+                recover();
+                return;
+            }
+            state = { ...state, position: state.position + 1, health: 'healthy' };
+            scope.onInvalidated?.(undefined);
+            // Reinstallation precedes one checkpoint recovery pass; later work is
+            // event driven again. Degraded retries inspect directory metadata only.
+            onCommitted({ ...state });
+        }, 3000);
+        recovery.unref();
+    };
+    const wake = (path) => {
+        if (disposed || state.health !== 'healthy')
+            return;
+        scope.onInvalidated?.(path);
+        state = { ...state, position: state.position + 1 };
+        for (const cursor of cursors)
+            if (path === undefined || cursor.accepts(path))
+                cursor.position = state.position;
+        if (queued)
+            return;
+        queued = true;
+        queueMicrotask(() => {
+            queued = false;
+            if (disposed || state.health !== 'healthy')
+                return;
+            if (!discovery) {
+                const wait = discoveredAt + DISCOVERY_WINDOW_MS - performance.now();
+                if (wait <= 0) {
+                    discover(false);
+                    return;
+                }
+                discovery = setTimeout(() => { discovery = undefined; discover(true); }, wait);
+                discovery.unref();
+            }
+            // Covered directories were watched before this wake; directories created
+            // since the last pass are covered by the pending one.
+            onCommitted({ ...state });
+        });
+    };
+    const discover = (deferred) => {
+        if (disposed || state.health !== 'healthy')
+            return;
+        discoveredAt = performance.now();
+        let added;
+        try {
+            added = install();
+        }
+        catch (error) {
+            fail(error);
+            return;
+        }
+        // Every wake before a deferred pass was already delivered. Writes into
+        // directories it newly covers have no event of their own: treat as unknown.
+        if (deferred) {
+            if (!added)
+                return;
+            state = { ...state, position: state.position + 1 };
+            scope.onInvalidated?.(undefined);
+            for (const cursor of cursors)
+                cursor.position = state.position;
+        }
+        onCommitted({ ...state });
+    };
+    const direct = (path) => { if (paths.some(root => within(path, root)) || (configEnabled && path === config))
+        wake(path); };
+    let detach;
+    const dispose = () => { if (disposed)
+        return; disposed = true; clearTimeout(recovery); recovery = undefined; clearTimeout(discovery); discovery = undefined; detach?.(); for (const cursor of [...cursors])
+        cursor.dispose(); commits.delete(direct); signal.removeEventListener('abort', dispose); release(); };
+    if (!disposed) {
+        commits.add(direct);
+        detach = scope.subscribeMutations?.(wake);
+        signal.addEventListener('abort', dispose, { once: true });
+        try {
+            install();
+        }
+        catch (error) {
+            fail(error);
+        }
+    }
+    const snapshot = () => ({ ...state, ...(disposed ? { health: 'failed' } : {}) });
+    // View-local cursors share coverage and health, but unrelated file commits
+    // cannot invalidate a capture. Unknown wakes remain conservative.
+    const cursor = (accepts, lifetime) => {
+        const entry = { accepts, position: state.position, dispose() { cursors.delete(entry); lifetime.removeEventListener('abort', entry.dispose); } };
+        if (!disposed && !lifetime.aborted) {
+            cursors.add(entry);
+            lifetime.addEventListener('abort', entry.dispose, { once: true });
+        }
+        return { snapshot: () => ({ ...snapshot(), position: entry.position }), dispose: entry.dispose };
+    };
+    return { snapshot, cursor, dispose };
+}

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

@@ -59,7 +59,8 @@ export class RoleCreationService {
     }
     async createManaged(caller, requested) {
         const plan = this.previewSpawn({ origin: 'managed', caller, options: requested });
-        const creationActionId = randomUUID();
+        const creationActionId = requested.roomMemberStartup?.task_id
+            ? requested.creationActionId ?? randomUUID() : randomUUID();
         plan.options.creationActionId = creationActionId;
         const statePath = await this.launchSync(plan.options);
         const selectionSummary = (kind) => {
@@ -138,7 +139,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-removal-service.js

@@ -1,9 +1,11 @@
+import { retireNotificationTarget } from '../notifications/target-cleanup.js';
 import { cpSync, existsSync, mkdirSync, readdirSync, renameSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { loadConfig, ROLE_NAME_RE } from '../config.js';
 import { agentDir, stateRoot } from '../paths.js';
-import { rmRole } from '../ops.js';
+import { assertStandaloneRoleRemoval, rmRole } from '../ops.js';
 import { FleetError } from './errors.js';
+import { removeReminderState } from '../reminders/store.js';
 import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
     options;
@@ -18,6 +20,12 @@ export class RoleRemovalService {
         if (!ROLE_NAME_RE.test(requested))
             throw new FleetError('invalid_request', 'invalid role name');
         const cfg = loadConfig(this.options.configPath);
+        try {
+            assertStandaloneRoleRemoval(cfg, requested);
+        }
+        catch (error) {
+            throw new FleetError('conflict', error instanceof Error ? error.message : String(error));
+        }
         const names = new Set(cfg.roles.map(role => role.name));
         for (const root of [dirname(agentDir('_')), dirname(agentDir('_', true))]) {
             try {
@@ -76,8 +84,11 @@ export class RoleRemovalService {
         const stamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
         const recoveryPath = join(stateRoot(), 'recovery', 'removed', `${stamp}-${preview.role}`);
         mkdirSync(recoveryPath, { recursive: true, mode: 0o700 });
-        if (existsSync(sourceState))
+        if (existsSync(sourceState)) {
             cpSync(sourceState, join(recoveryPath, 'state'), { recursive: true });
+            // Recovery evidence is not a schedule: a removed agent's reminders end here.
+            removeReminderState(join(recoveryPath, 'state'));
+        }
         if (role && provesGeneratedAgentSource(agentDir(preview.role), cfg.files[0], role.sourceFile)
             && existsSync(role.sourceFile))
             cpSync(role.sourceFile, join(recoveryPath, basename(role.sourceFile)));
@@ -85,8 +96,11 @@ export class RoleRemovalService {
             await rmRole(cfg, preview.role, this.options.ops);
         else {
             await this.options.ops.backend.uninstall(preview.role);
-            if (existsSync(sourceState))
+            if (existsSync(sourceState)) {
                 renameSync(sourceState, join(recoveryPath, 'orphan-state'));
+                removeReminderState(join(recoveryPath, 'orphan-state'));
+            }
+            await retireNotificationTarget({ kind: 'agent', agentId: preview.role }).catch(() => { });
             this.options.ops.log(`removed orphaned backend/state '${preview.role}'`);
         }
         return { ...preview, removed: true, recoveryPath };

package/dist/application/role-repository.d.ts

@@ -14,8 +14,10 @@ export interface RoleRepositoryOptions {
 export declare class RoleRepository {
     private readonly options;
     constructor(options?: RoleRepositoryOptions);
-    list(): Promise<RoleRecord[]>;
+    list(strict?: boolean): Promise<RoleRecord[]>;
     get(id: string): Promise<RoleRecord | undefined>;
+    private scan;
+    private record;
     stateDir(record: RoleRecord): string | undefined;
     private detect;
 }

package/dist/application/role-repository.js

@@ -1,17 +1,34 @@
 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;
-function safeDirs(root) {
+function retainedTaskId(dir, name) {
+    try {
+        const path = join(dir, '.temp-supervisor.json');
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024)
+            return undefined;
+        const record = JSON.parse(readFileSync(path, 'utf8'));
+        const id = record?.taskOwner?.taskId;
+        return record?.version === 1 && record?.role === name && typeof id === 'string'
+            && /^[0-9a-z]{9}[0-9a-f]{8}$/.test(id) ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeDirs(root, strict = false) {
     try {
         return readdirSync(root, { withFileTypes: true })
             .filter(entry => entry.isDirectory() && !entry.isSymbolicLink() && ROLE_NAME_RE.test(entry.name))
             .map(entry => entry.name);
     }
-    catch {
+    catch (error) {
+        if (strict && error.code !== 'ENOENT')
+            throw error;
         return [];
     }
 }
@@ -54,7 +71,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)',
             },
         };
@@ -86,7 +103,21 @@ export class RoleRepository {
     constructor(options = {}) {
         this.options = options;
     }
-    async list() {
+    async list(strict = false) {
+        const scan = this.scan(strict);
+        const names = [...new Set([...scan.configuredByName.keys(), ...scan.permanent, ...scan.temporary])].sort();
+        return boundedMap(names, this.options.concurrency ?? 8, name => this.record(scan, name, strict));
+    }
+    // One role's record is built from its own state and probe; the other roles are never probed.
+    async get(id) {
+        if (!ROLE_NAME_RE.test(id))
+            return undefined;
+        const scan = this.scan(false);
+        if (!scan.configuredByName.has(id) && !scan.permanent.has(id) && !scan.temporary.has(id))
+            return undefined;
+        return this.record(scan, id, false);
+    }
+    scan(strict) {
         const permanentRoot = this.options.permanentRoot ?? agentsRoot();
         const temporaryRoot = this.options.temporaryRoot ?? tmpRoot();
         let configured = [];
@@ -95,58 +126,62 @@ export class RoleRepository {
             configured = loadConfig(this.options.configPath).roles;
         }
         catch (error) {
+            if (strict)
+                throw error;
             configProblem = { code: 'config_invalid', severity: 'error', source: 'config', detail: error.message };
         }
-        const permanent = new Set(safeDirs(permanentRoot));
-        const temporary = new Set(safeDirs(temporaryRoot));
-        const configuredByName = new Map(configured.map(role => [role.name, role]));
-        const names = [...new Set([...configuredByName.keys(), ...permanent, ...temporary])].sort();
-        return boundedMap(names, this.options.concurrency ?? 8, async (name) => {
-            const config = configuredByName.get(name);
-            const inPermanent = permanent.has(name);
-            const inTemporary = temporary.has(name);
-            const problems = configProblem ? [configProblem] : [];
-            let tempRole;
-            let stateHealth = inPermanent || inTemporary ? 'present' : 'missing';
-            if (inTemporary) {
-                const read = snapshot(join(temporaryRoot, name, 'role.yaml'), name);
-                tempRole = read.role;
-                if (read.problem) {
-                    problems.push(read.problem);
-                    stateHealth = 'corrupt';
-                }
-            }
-            if (inPermanent && inTemporary)
-                problems.push({ code: 'duplicate_state', severity: 'error', detail: 'both permanent and temporary state exist' });
-            const intended = config?.session ?? tempRole?.session;
-            const detected = await this.detect(name, intended);
-            if (intended && detected !== 'none' && detected !== intended && detected !== 'ambiguous')
-                problems.push({
-                    code: 'backend_mismatch', severity: 'warning',
-                    detail: `configured ${intended}, detected ${detected}`,
-                });
-            const stateRef = inTemporary ? { lifetime: 'temporary' }
-                : inPermanent ? { lifetime: 'permanent' } : undefined;
-            const tempStateDir = inTemporary ? join(temporaryRoot, name) : undefined;
-            return {
-                id: name,
-                lifetime: config ? 'permanent' : inTemporary ? 'temporary' : 'orphan',
-                configured: Boolean(config),
-                config: config ? view(config) : tempRole ? view(tempRole) : undefined,
-                stateRef,
-                stateHealth,
-                configuredBackend: intended,
-                detectedBackend: detected,
-                compatibility: { compatible: true },
-                problems,
-                lineage: tempStateDir ? readSpawnLineage(tempStateDir) : undefined,
-            };
-        });
+        return {
+            temporaryRoot, configProblem,
+            permanent: new Set(safeDirs(permanentRoot, strict)),
+            temporary: new Set(safeDirs(temporaryRoot, strict)),
+            configuredByName: new Map(configured.map(role => [role.name, role])),
+        };
     }
-    async get(id) {
-        if (!ROLE_NAME_RE.test(id))
-            return undefined;
-        return (await this.list()).find(role => role.id === id);
+    async record(scan, name, strict) {
+        const { temporaryRoot, configProblem } = scan;
+        const config = scan.configuredByName.get(name);
+        const inPermanent = scan.permanent.has(name);
+        const inTemporary = scan.temporary.has(name);
+        const problems = configProblem ? [configProblem] : [];
+        let tempRole;
+        let stateHealth = inPermanent || inTemporary ? 'present' : 'missing';
+        if (inTemporary) {
+            const read = snapshot(join(temporaryRoot, name, 'role.yaml'), name);
+            tempRole = read.role;
+            if (strict && read.problem)
+                throw new Error('temporary role snapshot unavailable');
+            if (read.problem) {
+                problems.push(read.problem);
+                stateHealth = 'corrupt';
+            }
+        }
+        if (inPermanent && inTemporary)
+            problems.push({ code: 'duplicate_state', severity: 'error', detail: 'both permanent and temporary state exist' });
+        const intended = config?.session ?? tempRole?.session;
+        const detected = await this.detect(name, intended);
+        if (intended && detected !== 'none' && detected !== intended && detected !== 'ambiguous')
+            problems.push({
+                code: 'backend_mismatch', severity: 'warning',
+                detail: `configured ${intended}, detected ${detected}`,
+            });
+        const stateRef = inTemporary ? { lifetime: 'temporary' }
+            : inPermanent ? { lifetime: 'permanent' } : undefined;
+        const tempStateDir = inTemporary ? join(temporaryRoot, name) : undefined;
+        const taskId = !config && tempStateDir ? retainedTaskId(tempStateDir, name) : undefined;
+        return {
+            id: name,
+            lifetime: config ? 'permanent' : inTemporary ? 'temporary' : 'orphan',
+            configured: Boolean(config),
+            ...(taskId ? { taskId } : {}),
+            config: config ? view(config) : tempRole ? view(tempRole) : undefined,
+            stateRef,
+            stateHealth,
+            configuredBackend: intended,
+            detectedBackend: detected,
+            compatibility: { compatible: true },
+            problems,
+            lineage: tempStateDir ? readSpawnLineage(tempStateDir) : undefined,
+        };
     }
     stateDir(record) {
         if (!record.stateRef)

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;
+    }>;
+}