@ours.network/fleet 1.2.0-nightly.5 → 1.2.0-nightly.51

package/dist/rooms-tasks/layout-service.js

@@ -0,0 +1,185 @@
+import { randomUUID, createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, loadRoomsConfig, splitRootFor } from '../config.js';
+import { agentDir, stateRoot, defaultConfigPath } from '../paths.js';
+import { controlRequest } from '../session/control.js';
+import { spawnTemp } from '../spawn.js';
+import { tempSupervisorLiveness } from '../temp-lifecycle.js';
+import { layoutSupervisorId } from './layout-control.js';
+import { RoomLayout } from './layout.js';
+import { assertLayoutFile, validLayoutKey, readRoomLayout, readRoomLayouts } from './layout-config.js';
+import { createCoworkAdapter } from './cowork-adapter.js';
+import { callRemoteLayoutBinding } from './layout-binding-client.js';
+import { readClientProfile } from '../client-profile.js';
+export class NativeLayoutSupervisor {
+    configPath;
+    runId;
+    templates;
+    id;
+    constructor(configPath, runId, templates) {
+        this.configPath = configPath;
+        this.runId = runId;
+        this.templates = templates;
+        mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
+        this.id = layoutSupervisorId();
+    }
+    async request(agent, temporary, request) {
+        if (!/^[A-Za-z0-9_-]+$/.test(agent))
+            throw Error('invalid agent name');
+        const response = await controlRequest(agentDir(agent, temporary), { command: 'layout_control', layout: request }, 60_000);
+        if (!response.ok)
+            throw Error(response.error ?? 'layout control rejected');
+        return response.result;
+    }
+    async inspect(agent, temporary) {
+        return await this.request(agent, temporary, { action: 'inspect' });
+    }
+    call(i, request) {
+        if (i.remote)
+            return callRemoteLayoutBinding(i, request, readClientProfile().expectedInstanceId);
+        if (i.supervisor !== this.id || !i.agent || typeof i.temporary !== 'boolean')
+            throw Error('invalid local layout binding');
+        return this.request(i.agent, i.temporary, { ...request, instance: i });
+    }
+    async verify(i) { await this.call(i, { action: 'verify' }); }
+    async spawn(key, template) {
+        const definition = this.templates[template];
+        if (!definition)
+            throw Error(`agent template not found in run snapshot: ${template}`);
+        const name = `layout-${createHash('sha256').update(this.runId + ':' + key).digest('hex').slice(0, 16)}`;
+        await spawnTemp({ name, temp: true, configPath: this.configPath, agentDefinition: definition,
+            creationActionId: `${this.runId}:${key}`, surface: 'cli' }, fileURLToPath(new URL('../cli.js', import.meta.url)));
+        const deadline = Date.now() + 120_000;
+        let last;
+        while (Date.now() < deadline) {
+            try {
+                return await this.inspect(name, true);
+            }
+            catch (e) {
+                last = e;
+            }
+            await new Promise(resolve => setTimeout(resolve, 250));
+        }
+        throw Error(`layout agent startup not confirmed: ${name}: ${String(last)}`);
+    }
+    async join(i, invite, roomCid, membership) {
+        if (i.remote) {
+            if (!membership)
+                throw Error('cross-Fleet join requires room ID and role');
+            await this.call(i, { action: 'join', roomCid, roomId: membership.roomId, roomRole: membership.role });
+            return;
+        }
+        await this.call(i, { action: 'join', invite, roomCid });
+        const cowork = createCoworkAdapter();
+        const deadline = Date.now() + 30_000;
+        while (Date.now() < deadline) {
+            const rooms = await cowork.listRooms();
+            if (rooms.some(r => r.identity_cid === roomCid && r.seats.some(s => s.identity_cid === i.cid && s.seat_state !== 'removed')))
+                return;
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        throw Error('room admission not observed');
+    }
+    async assign(i, assignment) {
+        await this.call(i, { action: 'assign', assignment });
+    }
+    async retire(i) {
+        if (i.remote)
+            throw Error('cannot retire a borrowed cross-Fleet instance');
+        if (i.supervisor !== this.id || !i.agent || !/^[A-Za-z0-9_-]+$/.test(i.agent) || i.temporary !== true)
+            throw Error('invalid local temporary layout instance');
+        const dir = agentDir(i.agent, true);
+        const stopped = async () => !existsSync(dir) || await tempSupervisorLiveness(dir) === 'stopped';
+        if (await stopped())
+            return;
+        try {
+            await this.call(i, { action: 'retire' });
+        }
+        catch (error) {
+            if (!await stopped())
+                throw error;
+        }
+    }
+}
+export const layoutRunPath = (id) => {
+    if (!validLayoutKey(id))
+        throw Error('invalid layout run ID');
+    const root = join(stateRoot(), 'layouts');
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    assertLayoutFile(root, true);
+    return join(root, id + '.json');
+};
+export class RoomLayoutService {
+    configPath;
+    constructor(configPath) {
+        this.configPath = configPath;
+    }
+    list() {
+        const layouts = readRoomLayouts(join(splitRootFor(this.configPath ?? defaultConfigPath()), 'room_layouts'), []);
+        const cfg = loadConfig(this.configPath);
+        for (const [name, layout] of Object.entries(layouts))
+            for (const participant of Object.values(layout.participants))
+                if (participant.agent_template && !cfg.agentTemplates?.[participant.agent_template])
+                    throw Error(`room layout ${name}: agent template not found: ${participant.agent_template}`);
+        return layouts;
+    }
+    /** Reads only the named file, so an unrelated broken layout cannot block this one. */
+    definition(name) {
+        if (!validLayoutKey(name))
+            throw Error(`room layout not found: ${name}`);
+        const root = join(splitRootFor(this.configPath ?? defaultConfigPath()), 'room_layouts');
+        const files = existsSync(root) ? (assertLayoutFile(root, true), readdirSync(root).filter(f => f === `${name}.yaml` || f === `${name}.yml`)) : [];
+        if (files.length > 1)
+            throw Error(`duplicate room layout: ${name}`);
+        if (!files.length)
+            throw Error(`room layout not found: ${name}`);
+        const def = readRoomLayout(join(root, files[0]));
+        const cfg = loadConfig(this.configPath);
+        for (const participant of Object.values(def.participants))
+            if (participant.agent_template && !cfg.agentTemplates?.[participant.agent_template])
+                throw Error(`room layout ${name}: agent template not found: ${participant.agent_template}`);
+        return def;
+    }
+    supervisor(id = 'inspect', templates = {}) {
+        return new NativeLayoutSupervisor(this.configPath, id, templates);
+    }
+    owner() {
+        const rooms = loadRoomsConfig(this.configPath);
+        if (rooms.defaults?.attach_owner === false)
+            return undefined;
+        if (!rooms._invite)
+            throw Error('room owner invite required; configure rooms.owner or explicitly set rooms.defaults.attach_owner: false');
+        return { cid: rooms.owner.expected_cid, role: rooms.owner.role ?? 'Owner', invite: rooms._invite.value };
+    }
+    engine(id, cleanup = false) {
+        const path = layoutRunPath(id);
+        if (existsSync(path))
+            assertLayoutFile(path);
+        return new RoomLayout(path, () => createCoworkAdapter(), this.supervisor(id), cleanup ? undefined : this.owner());
+    }
+    open(id, cleanup = false) {
+        const initial = this.engine(id, cleanup), snapshot = initial.snapshot();
+        return new RoomLayout(layoutRunPath(id), () => createCoworkAdapter(), this.supervisor(id, snapshot.agent_templates ?? {}), cleanup ? undefined : this.owner());
+    }
+    /** `scope` lets an owner (e.g. a Task) snapshot an adjusted definition and pin agent working directories. */
+    async create(name, bindings = {}, id = `run-${randomUUID()}`, scope = {}) {
+        const cfg = loadConfig(this.configPath);
+        // A caller that already verified the source passes it, so no second read can race an edit.
+        const source = scope.source ?? this.definition(name);
+        const definition = scope.definition ? scope.definition(structuredClone(source)) : source;
+        const templates = {};
+        for (const [key, participant] of Object.entries(definition.participants)) {
+            if (bindings[key] || !participant.agent_template)
+                continue;
+            const template = cfg.agentTemplates?.[participant.agent_template];
+            if (!template)
+                throw Error(`agent template not found: ${participant.agent_template}`);
+            templates[participant.agent_template] = { ...structuredClone(template), ...(scope.cwd ? { cwd: scope.cwd } : {}) };
+        }
+        const engine = this.engine(id);
+        await engine.create(definition, layoutSupervisorId(), bindings, templates);
+        return { id, state: engine.snapshot() };
+    }
+}

package/dist/rooms-tasks/layout.d.ts

@@ -0,0 +1,114 @@
+import type { CoworkAdapter, CoworkRoomCreateResult } from './cowork-adapter.js';
+export interface LayoutOwner {
+    cid: string;
+    role: string;
+    invite: string;
+}
+declare const ownerReference: (owner: LayoutOwner) => {
+    cid: string;
+    role: string;
+    fingerprint: string;
+};
+export interface LayoutInstance {
+    supervisor: string;
+    launch: string;
+    cid: string;
+    session: string;
+    agent?: string;
+    temporary?: boolean;
+    remote?: {
+        url: string;
+        grant_id: string;
+        credential_file: string;
+        daemon_instance_id: string;
+    };
+}
+export interface LayoutParticipant {
+    agent_template?: string;
+    instance_scope?: 'layout' | 'room';
+}
+export interface LayoutRoom {
+    goal: string;
+    members: string[];
+    contract?: string;
+    quiet_membership?: boolean;
+    anonymous?: boolean;
+    roles?: Record<string, string>;
+}
+export interface LayoutDefinition {
+    participants: Record<string, LayoutParticipant>;
+    rooms: Record<string, LayoutRoom>;
+}
+export interface LayoutAssignment {
+    id: string;
+    room_id: string;
+    room_cid: string;
+    goal: string;
+    participant: string;
+    room_role?: string;
+    contract?: string;
+}
+export interface LayoutSupervisor {
+    id: string;
+    /** Must verify current launch, CID, live session and standalone ownership. */
+    verify(instance: LayoutInstance): Promise<void>;
+    spawn(key: string, template: string): Promise<LayoutInstance>;
+    join(instance: LayoutInstance, invite: string, roomCid: string, membership?: {
+        roomId: string;
+        role: string;
+    }): Promise<void>;
+    assign(instance: LayoutInstance, assignment: LayoutAssignment): Promise<void>;
+    /** Retire the exact instance, or confirm it is already stopped; never stop a replacement. */
+    retire(instance: LayoutInstance): Promise<void>;
+}
+type ParticipantState = {
+    instance?: LayoutInstance;
+    owned: boolean;
+    retired?: boolean;
+    participant?: string;
+    room?: string;
+};
+type RoomState = {
+    spec: LayoutRoom;
+    native?: CoworkRoomCreateResult;
+    ready: string[];
+    state: 'provisioning' | 'active' | 'closed';
+    owner_ready?: boolean;
+};
+export interface RoomLayoutState {
+    version: 1;
+    owner?: ReturnType<typeof ownerReference>;
+    agent_templates?: Record<string, import('../config.js').AgentTemplateDefinition>;
+    definition: LayoutDefinition;
+    controller: string;
+    participants: Record<string, ParticipantState>;
+    rooms: Record<string, RoomState>;
+    order: string[];
+    closed: boolean;
+    closing?: boolean;
+    uncertain?: string;
+}
+export declare function validateLayout(def: LayoutDefinition): void;
+export declare class RoomLayout {
+    private file;
+    private supervisor;
+    private owner?;
+    private coworkAdapter?;
+    private readonly coworkFactory;
+    constructor(file: string, cowork: CoworkAdapter | (() => CoworkAdapter), supervisor: LayoutSupervisor, owner?: LayoutOwner | undefined);
+    private get cowork();
+    snapshot(): RoomLayoutState;
+    private save;
+    private verify;
+    create(definition: LayoutDefinition, controller: string, bindings?: Record<string, LayoutInstance>, agentTemplates?: RoomLayoutState['agent_templates']): Promise<void>;
+    private checkOwnerRoles;
+    private operation;
+    private mutation;
+    private activateRoom;
+    activate(actor: string, key: string): Promise<void>;
+    private assertRoomActive;
+    private archiveRoom;
+    closeRoom(actor: string, key: string): Promise<void>;
+    close(actor: string): Promise<void>;
+}
+export {};

package/dist/rooms-tasks/layout.js

@@ -0,0 +1,250 @@
+/** Durable local room-layout controller.
+ * Uses native Cowork operations and a supervising Fleet's exact-instance port.
+ * Unknown mutation outcomes stop for reconciliation; they are never replayed.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { canonicalJson } from '../canonical-json.js';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+const ownerReference = (owner) => ({ cid: owner.cid, role: owner.role, fingerprint: createHash('sha256').update(owner.invite).digest('hex') });
+const own = (o, key) => Object.hasOwn(o, key);
+function need(ok, message) { if (!ok)
+    throw Error(message); }
+/** Room/participant keys cannot contain ':', so scoped instance keys cannot collide. */
+function instanceKey(definition, participant, room) {
+    return definition.participants[participant].instance_scope === 'room' ? `${room}:${participant}` : participant;
+}
+export function validateLayout(def) {
+    need(Object.keys(def.rooms).length && Object.keys(def.participants).length, 'rooms and participants required');
+    for (const [key, participant] of Object.entries(def.participants)) {
+        need(participant.instance_scope === undefined || ['layout', 'room'].includes(participant.instance_scope), `invalid instance_scope for ${key}`);
+        if (participant.instance_scope === 'room')
+            need(typeof participant.agent_template === 'string' && participant.agent_template.trim(), `room-scoped participant ${key} requires agent_template`);
+    }
+    for (const [key, room] of Object.entries(def.rooms)) {
+        need(key.length && room.goal.trim() && room.members.length, 'room goal and members required');
+        need(new Set(room.members).size === room.members.length, 'duplicate participant in room');
+        for (const member of room.members)
+            need(own(def.participants, member), `unknown participant ${member}`);
+    }
+    for (const key of [...Object.keys(def.rooms), ...Object.keys(def.participants)])
+        need(/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(key) && !['constructor', 'prototype', '__proto__'].includes(key), 'invalid layout key');
+}
+export class RoomLayout {
+    file;
+    supervisor;
+    owner;
+    coworkAdapter;
+    coworkFactory;
+    constructor(file, cowork, supervisor, owner) {
+        this.file = file;
+        this.supervisor = supervisor;
+        this.owner = owner;
+        this.coworkFactory = typeof cowork === 'function' ? cowork : () => cowork;
+    }
+    get cowork() { return this.coworkAdapter ??= this.coworkFactory(); }
+    snapshot() { return JSON.parse(readFileSync(this.file, 'utf8')); }
+    save(s) { replaceFileAtomically(this.file, JSON.stringify(s, null, 2)); }
+    async verify(i) {
+        need(i.supervisor === this.supervisor.id || i.remote, 'remote binding unsupported');
+        need(i.launch && i.cid && i.session, 'incomplete instance reference');
+        await this.supervisor.verify(i);
+    }
+    async create(definition, controller, bindings = {}, agentTemplates) {
+        validateLayout(definition);
+        need(controller, 'controller required');
+        this.checkOwnerRoles(definition);
+        await withFileLock(this.file + '.lock', async () => {
+            need(!existsSync(this.file), 'layout instance already exists');
+            for (const key of Object.keys(bindings)) {
+                need(own(definition.participants, key), 'unknown binding');
+                need(definition.participants[key].instance_scope !== 'room', `binding unsupported for room-scoped participant ${key}`);
+            }
+            // Validate every supplied binding before any external mutation.
+            for (const [key, p] of Object.entries(definition.participants)) {
+                need(bindings[key] || p.agent_template, `binding required for ${key}`);
+                if (bindings[key])
+                    await this.verify(bindings[key]);
+            }
+            for (const room of Object.values(definition.rooms)) {
+                const cids = room.members.flatMap(key => bindings[key] ? [bindings[key].cid] : []);
+                need(new Set(cids).size === cids.length, 'same instance cannot occupy two seats in one room');
+            }
+            const participants = {};
+            for (const [key, participant] of Object.entries(definition.participants)) {
+                if (participant.instance_scope === 'room') {
+                    for (const [room, spec] of Object.entries(definition.rooms))
+                        if (spec.members.includes(key))
+                            participants[instanceKey(definition, key, room)] = { owned: true, participant: key, room };
+                }
+                else
+                    participants[key] = { owned: !bindings[key], ...(bindings[key] ? { instance: bindings[key] } : {}) };
+            }
+            this.save({ version: 1, definition, controller, ...(this.owner ? { owner: ownerReference(this.owner) } : {}),
+                agent_templates: agentTemplates, participants, rooms: {}, order: [], closed: false });
+        });
+    }
+    checkOwnerRoles(definition) {
+        if (!this.owner)
+            return;
+        for (const room of Object.values(definition.rooms))
+            need(room.members.every(member => (room.roles?.[member] ?? member) !== this.owner.role), 'participant cannot use the owner role');
+    }
+    async operation(actor, work, cleanup = false) {
+        return withFileLock(this.file + '.lock', async () => {
+            const s = this.snapshot();
+            need(actor === s.controller, 'controller authorization required');
+            if (!cleanup) {
+                need(!s.closed && !s.closing, 'layout instance closing or closed');
+                need(!s.uncertain, `reconciliation required: ${s.uncertain}`);
+            }
+            return work(s);
+        });
+    }
+    async mutation(s, id, work, commit) {
+        s.uncertain = id;
+        this.save(s);
+        // On any error keep the cursor, even if the operation may have succeeded.
+        const result = await work();
+        commit(result);
+        delete s.uncertain;
+        this.save(s);
+    }
+    async activateRoom(s, key, spec) {
+        if (s.owner)
+            need(this.owner && canonicalJson(s.owner) === canonicalJson(ownerReference(this.owner)), 'room owner configuration changed');
+        this.checkOwnerRoles(s.definition);
+        need(s.rooms[key]?.state !== 'closed', 'room closed');
+        for (const member of spec.members) {
+            const p = s.participants[instanceKey(s.definition, member, key)];
+            const i = p?.instance;
+            if (i)
+                await this.verify(i);
+            need(!p?.retired, 'participant retired');
+        }
+        if (s.rooms[key]?.state === 'active') {
+            await this.assertRoomActive(s, key);
+            return;
+        }
+        const room = s.rooms[key] ??= { spec, state: 'provisioning', ready: [] };
+        this.save(s);
+        for (const member of spec.members) {
+            const resolvedKey = instanceKey(s.definition, member, key), p = s.participants[resolvedKey];
+            if (!p.instance) {
+                const template = s.definition.participants[member]?.agent_template;
+                need(template, `no factory for ${member}`);
+                await this.mutation(s, `spawn:${resolvedKey}`, () => this.supervisor.spawn(resolvedKey, template), i => { p.instance = i; });
+                await this.verify(p.instance);
+            }
+        }
+        const roleFor = (member) => spec.roles?.[member] ?? member;
+        if (!room.native)
+            await this.mutation(s, `create:${key}`, () => this.cowork.createRoom({
+                room_name: `${key.slice(0, 24)}-${createHash('sha256').update(this.file + '\0' + key).digest('hex').slice(0, 24)}`,
+                goal: spec.goal, briefing: JSON.stringify({ goal: spec.goal, contract: spec.contract }),
+                quiet_membership: spec.quiet_membership ?? true, anonymous: spec.anonymous ?? false,
+                activation_requirements: [...new Set(spec.members.map(roleFor))].map(role => ({ role, count: spec.members.filter(m => roleFor(m) === role).length })),
+            }), native => { room.native = native; s.order.push(key); });
+        if (s.owner && !room.owner_ready)
+            await this.mutation(s, `owner:${key}`, async () => {
+                await this.cowork.acceptInvite(room.native.room_id, this.owner.invite, { role: s.owner.role, expected_cid: s.owner.cid });
+                await this.cowork.setRoleCommands(room.native.room_id, { role: s.owner.role, commands: ['*'] });
+            }, () => { room.owner_ready = true; });
+        for (const member of spec.members) {
+            if (room.ready.includes(member))
+                continue;
+            const i = s.participants[instanceKey(s.definition, member, key)].instance;
+            await this.verify(i);
+            const seats = await this.cowork.getSeats(room.native.room_id);
+            if (!seats.some(seat => seat.identity_cid === i.cid && seat.role === roleFor(member) && seat.seat_state !== 'removed')) {
+                await this.mutation(s, `admit:${key}:${member}`, async () => {
+                    const invite = i.remote ? '' : (await this.cowork.issueInvite(room.native.room_id, { mode: 'one_time', role: roleFor(member), min_accepts: 1 })).invite;
+                    await this.supervisor.join(i, invite, room.native.identity_cid, { roomId: room.native.room_id, role: roleFor(member) });
+                }, () => { });
+            }
+        }
+        await this.assertRoomActive(s, key);
+        // Admission of all required seats precedes any participant work.
+        for (const member of spec.members) {
+            if (room.ready.includes(member))
+                continue;
+            const i = s.participants[instanceKey(s.definition, member, key)].instance;
+            await this.verify(i);
+            await this.mutation(s, `assignment:${key}:${member}`, () => this.supervisor.assign(i, {
+                id: `${key}:${member}`, room_id: room.native.room_id, room_cid: room.native.identity_cid,
+                participant: member, room_role: roleFor(member), goal: spec.goal, contract: spec.contract,
+            }), () => { room.ready.push(member); });
+        }
+        room.state = 'active';
+        this.save(s);
+    }
+    activate(actor, key) {
+        return this.operation(actor, async (s) => {
+            need(own(s.definition.rooms, key), 'unknown room');
+            await this.activateRoom(s, key, s.definition.rooms[key]);
+        });
+    }
+    async assertRoomActive(s, key) {
+        const room = s.rooms[key], native = await this.cowork.getRoom(room.native.room_id);
+        need(native?.identity_cid === room.native.identity_cid && native.state === 'active', 'native room missing, changed or inactive');
+        if (s.owner)
+            need(native.seats.some(seat => seat.identity_cid.toLowerCase() === s.owner.cid.toLowerCase()
+                && seat.role === s.owner.role && seat.seat_state === 'active'), 'owner membership not active');
+        need(room.spec.members.every(member => native.seats.some(seat => seat.identity_cid === s.participants[instanceKey(s.definition, member, key)].instance.cid
+            && seat.role === (room.spec.roles?.[member] ?? member) && seat.seat_state === 'active')), 'membership not active');
+    }
+    async archiveRoom(s, key) {
+        const room = s.rooms[key];
+        need(room?.native, 'room not created');
+        if (room.state === 'closed')
+            return;
+        const native = await this.cowork.getRoom(room.native.room_id);
+        if (native) {
+            need(native.identity_cid === room.native.identity_cid, 'native room identity changed');
+            if (native.state !== 'closed')
+                await this.cowork.closeRoom(room.native.room_id);
+        }
+        room.state = 'closed';
+        this.save(s);
+    }
+    closeRoom(actor, key) {
+        return this.operation(actor, s => this.archiveRoom(s, key), true);
+    }
+    close(actor) {
+        return this.operation(actor, async (s) => {
+            if (s.closed)
+                return;
+            s.closing = true;
+            this.save(s);
+            const errors = [];
+            for (const key of [...s.order].reverse()) {
+                try {
+                    await this.archiveRoom(s, key);
+                }
+                catch (error) {
+                    errors.push(`room ${key}: ${String(error)}`);
+                }
+            }
+            for (const [key, p] of Object.entries(s.participants))
+                if (p.owned && p.instance && !p.retired) {
+                    try {
+                        need(p.instance.supervisor === this.supervisor.id, 'remote binding unsupported');
+                        await this.supervisor.retire(p.instance);
+                        p.retired = true;
+                        this.save(s);
+                    }
+                    catch (error) {
+                        errors.push(`participant ${key}: ${String(error)}`);
+                    }
+                }
+            // Clean known resources without erasing evidence of an unknown creation outcome.
+            if (s.uncertain)
+                errors.push(`known resources cleaned where possible; inspection still required: ${s.uncertain}`);
+            if (errors.length)
+                throw Error(`layout cleanup incomplete: ${errors.join('; ')}`);
+            s.closed = true;
+            delete s.closing;
+            this.save(s);
+        }, true);
+    }
+}

package/dist/rooms-tasks/live-readiness.d.ts

@@ -0,0 +1,18 @@
+import { readRoomReadiness } from '../agent-ours/service.js';
+import { controlRequest } from '../session/control.js';
+import { readTempSupervisor, tempSupervisorLiveness } from '../temp-lifecycle.js';
+import type { CoworkAdapter } from './cowork-adapter.js';
+import type { RoomOrchestrationRecord, TaskRecord } from './types.js';
+export type TaskReadinessIssue = {
+    state: 'degraded' | 'unknown';
+    reason: string;
+    member?: string;
+};
+export interface LiveReadinessDeps {
+    supervisor?: typeof readTempSupervisor;
+    liveness?: typeof tempSupervisorLiveness;
+    readiness?: typeof readRoomReadiness;
+    control?: typeof controlRequest;
+}
+/** Read-only observation. A failed probe never grants authority to replace a seat. */
+export declare function taskLiveReadiness(task: TaskRecord, room: RoomOrchestrationRecord | undefined, cowork: Pick<CoworkAdapter, 'getRoom'>, deps?: LiveReadinessDeps): Promise<TaskReadinessIssue | undefined>;

package/dist/rooms-tasks/live-readiness.js

@@ -0,0 +1,85 @@
+import { realExec } from '../exec.js';
+import { agentDir } from '../paths.js';
+import { readRoomReadiness } from '../agent-ours/service.js';
+import { controlRequest } from '../session/control.js';
+import { readTempSupervisor, tempSupervisorLiveness } from '../temp-lifecycle.js';
+/** Read-only observation. A failed probe never grants authority to replace a seat. */
+export async function taskLiveReadiness(task, room, cowork, deps = {}) {
+    const degraded = (reason, member) => ({ state: 'degraded', reason, member });
+    const unknown = (reason, member) => ({ state: 'unknown', reason, member });
+    if (!room || task.state !== 'active' || task.room_id !== room.room_id || room.state !== 'active' || room.close || task.terminal_intent
+        || room.task_id !== task.task_id || !room.room_identity_cid
+        || task.room_identity_cid !== room.room_identity_cid)
+        return degraded('room_record_mismatch');
+    const baseExpected = room.template_snapshot?.members.reduce((n, member) => n + member.count, 0);
+    const expected = baseExpected === undefined ? undefined : baseExpected + (room.additional_member_templates ?? []).reduce((n, t) => n + t.members.reduce((m, s) => m + s.count, 0), 0);
+    if (expected === undefined || room.member_seats.length !== expected
+        || new Set(room.member_seats.map(seat => seat.role_name)).size !== expected
+        || new Set(room.member_seats.map(seat => seat.identity_cid)).size !== expected)
+        return degraded('member_roster_mismatch');
+    let remote;
+    try {
+        remote = await cowork.getRoom(room.room_id);
+    }
+    catch {
+        return unknown('room_probe_unavailable');
+    }
+    if (!remote || remote.room_id !== room.room_id || remote.identity_cid !== room.room_identity_cid
+        || remote.state !== 'active')
+        return degraded('room_identity_or_state_mismatch');
+    if (room.owner_seat_cid && remote.seats.filter(seat => seat.identity_cid.toLowerCase() === room.owner_seat_cid.toLowerCase() && seat.seat_state === 'active').length !== 1)
+        return degraded('owner_seat_missing');
+    for (const seat of room.member_seats) {
+        const member = seat.role_name;
+        if (!/^[A-Za-z0-9_-]+$/.test(member) || seat.seat_state !== 'active' || !seat.identity_cid || !seat.invite_id
+            || seat.launch?.state !== 'launched' || !seat.launch.launch_id || seat.retirement)
+            return degraded('member_record_incomplete', member);
+        const matches = remote.seats.filter(item => item.display_name === member && item.seat_state !== 'removed');
+        if (matches.length !== 1 || matches[0].identity_cid !== seat.identity_cid
+            || matches[0].invite_id !== seat.invite_id || matches[0].role !== seat.cowork_role
+            || matches[0].seat_state !== 'active')
+            return degraded('member_seat_mismatch', member);
+        const dir = agentDir(member, true);
+        try {
+            const supervisor = (deps.supervisor ?? readTempSupervisor)(dir);
+            if (!supervisor)
+                return unknown('supervisor_record_missing', member);
+            if (supervisor.role !== member || supervisor.launchId !== seat.launch.launch_id)
+                return degraded('supervisor_launch_mismatch', member);
+            const live = await (deps.liveness ?? tempSupervisorLiveness)(dir, {
+                exec: (cmd, args, opts) => realExec(cmd, args, { ...opts, timeout: 2_000 }),
+            });
+            if (live === 'stopped')
+                return degraded('supervisor_stopped', member);
+            if (live !== 'running')
+                return unknown('supervisor_liveness_unknown', member);
+            const ready = (deps.readiness ?? readRoomReadiness)(room.room_identity_cid, member);
+            if (!ready || ready.room !== room.room_id || ready.invite !== seat.invite_id || ready.cid !== seat.identity_cid)
+                return degraded('member_readiness_mismatch', member);
+        }
+        catch {
+            return unknown('supervisor_probe_unavailable', member);
+        }
+        try {
+            const response = await (deps.control ?? controlRequest)(dir, { command: 'status', controller: false }, 2_000);
+            if (!response.ok)
+                return unknown('control_unavailable', member);
+            const status = response.result;
+            if (status?.alive === false || status?.readiness === 'failed')
+                return degraded('agent_not_ready', member);
+            if (status?.alive !== true || !['idle', 'running', 'awaiting_permission'].includes(status.readiness ?? ''))
+                return unknown('agent_readiness_unknown', member);
+            const after = (deps.supervisor ?? readTempSupervisor)(dir);
+            if (!after || after.role !== member || after.launchId !== seat.launch.launch_id)
+                return degraded('supervisor_launch_changed', member);
+        }
+        catch {
+            return unknown('control_unavailable', member);
+        }
+    }
+    const memberCids = new Set(room.member_seats.map(seat => seat.identity_cid));
+    const memberRoles = new Set(room.member_seats.map(seat => seat.cowork_role));
+    if (remote.seats.some(seat => seat.seat_state === 'active' && memberRoles.has(seat.role)
+        && !memberCids.has(seat.identity_cid) && seat.identity_cid.toLowerCase() !== room.owner_seat_cid?.toLowerCase()))
+        return degraded('untracked_member_seats');
+}

package/dist/rooms-tasks/member-startup.d.ts

@@ -6,6 +6,7 @@ export interface RoomTaskMember {
 }
 /** Build the complete task text Fleet places directly in a temporary member's briefing. */
 export declare function buildRoomMemberTask(input: {
+    workspace?: string;
     taskId?: string;
     roomId: string;
     roomIdentityCid: string;