@ours.network/fleet 1.2.0-nightly.3 → 1.2.0-nightly.31

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;

package/dist/rooms-tasks/member-startup.js

@@ -7,6 +7,8 @@ export function buildRoomMemberTask(input) {
         `Fleet Task ${input.taskId ?? '(standalone)'} — ${member.cowork_role} in room ${input.roomId}`,
         '',
     ];
+    if (input.workspace)
+        lines.push(`Task-owned workspace: ${input.workspace}`, 'Start and keep all execution artifacts, dependency checkouts, and Git worktrees inside this workspace.', 'Clone repositories inside this workspace before adding worktrees; never attach to an external Git common directory.', 'Use distinct per-agent branches/directories for concurrent edits. Configured cwd is source context, not artifact ownership.', 'Completion, cancellation and room retirement retain artifacts. Only explicit owner deletion removes them.', 'Do not delete the workspace or its ownership marker yourself.', '');
     if (input.goal)
         lines.push(`Goal: ${input.goal}`);
     if (input.brief)

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

@@ -3,6 +3,7 @@ import type { RoomOrchestrationRecord, TemplateSnapshot } from './types.js';
 import { type FleetConfig } from '../config.js';
 export declare function getBinPath(): string;
 export interface ProvisionMembersInput {
+    configPath?: string;
     cfg: FleetConfig;
     cowork: CoworkAdapter;
     roomId: string;
@@ -12,6 +13,8 @@ export interface ProvisionMembersInput {
     brief?: string;
     goal?: string;
     startupWait?: Partial<StartupWaitPolicy>;
+    /** Append only the supplied new slots to an already active room. */
+    append?: boolean;
 }
 export interface StartupWaitPolicy {
     timeoutMs: number;
@@ -21,6 +24,17 @@ export interface StartupWaitPolicy {
     sleep(ms: number): Promise<void>;
 }
 export declare function provisionMembers(input: ProvisionMembersInput): Promise<RoomOrchestrationRecord>;
+/** Reconcile proven, admitted launches without any spawn, archive, invite or recovery path. */
+export declare function reconcileExistingTaskMembers(input: {
+    taskId: string;
+    checkOnly?: boolean;
+    cowork: Pick<CoworkAdapter, 'getRoom'>;
+    expectedLaunches: ReadonlyArray<{
+        role_name: string;
+        launch_id: string;
+        identity_cid: string;
+    }>;
+}): Promise<RoomOrchestrationRecord>;
 export declare function cleanupMembers(input: {
     roomId: string;
     taskId?: string;