@ours.network/fleet 0.19.0-nightly.1 → 0.19.0-nightly.3

package/dist/rooms-tasks/room-state.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { stateRoot } from '../paths.js';
+export const roomsDir = () => join(stateRoot(), 'rooms');
+function roomPath(id) { return join(roomsDir(), `${id}.json`); }
+export class RoomStateError extends Error {
+}
+function readRoom(id) {
+    const p = roomPath(id);
+    if (!existsSync(p))
+        throw new RoomStateError(`room not found: ${id}`);
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+function writeRoom(record) {
+    mkdirSync(roomsDir(), { recursive: true });
+    replaceFileAtomically(roomPath(record.room_id), JSON.stringify(record, null, 2) + '\n');
+}
+export function createRoomRecord(input) {
+    const existing = getRoomRecord(input.room_id);
+    if (existing)
+        return existing;
+    const record = {
+        room_id: input.room_id,
+        room_name: input.room_name,
+        room_identity_cid: input.room_identity_cid,
+        task_id: input.task_id,
+        template_snapshot: input.template_snapshot,
+        saga: { phase: 'persist_intent', step_index: 0 },
+        member_seats: [],
+        state: 'provisioning',
+        created_at: new Date().toISOString(),
+    };
+    writeRoom(record);
+    return record;
+}
+export function getRoomRecord(id) {
+    try {
+        return readRoom(id);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function listRoomRecords(filter) {
+    const dir = roomsDir();
+    if (!existsSync(dir))
+        return [];
+    const states = filter?.state
+        ? (Array.isArray(filter.state) ? filter.state : [filter.state])
+        : undefined;
+    const rooms = [];
+    for (const f of readdirSync(dir).filter(f => f.endsWith('.json'))) {
+        try {
+            const r = JSON.parse(readFileSync(join(dir, f), 'utf8'));
+            if (!states || states.includes(r.state))
+                rooms.push(r);
+        }
+        catch { /* skip corrupt */ }
+    }
+    return rooms.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+export function advanceSaga(id, phase, stepIndex, detail) {
+    const r = readRoom(id);
+    r.saga = { phase, step_index: stepIndex ?? 0 };
+    if (detail)
+        r.provisioning_detail = detail;
+    else
+        delete r.provisioning_detail;
+    writeRoom(r);
+    return r;
+}
+export function setSagaError(id, error, hint, detail) {
+    const r = readRoom(id);
+    r.saga.error = error;
+    r.saga.recovery_hint = hint;
+    if (detail)
+        r.provisioning_detail = detail;
+    writeRoom(r);
+    return r;
+}
+export function setRoomIdentity(id, roomIdentityCid) {
+    const r = readRoom(id);
+    r.room_identity_cid = roomIdentityCid;
+    writeRoom(r);
+    return r;
+}
+export function setOwnerSeat(id, ownerSeatCid, inviteFingerprint) {
+    const r = readRoom(id);
+    r.owner_seat_cid = ownerSeatCid;
+    r.owner_invite_fingerprint = inviteFingerprint;
+    writeRoom(r);
+    return r;
+}
+export function updateMemberSeats(id, seats) {
+    const r = readRoom(id);
+    r.member_seats = seats;
+    writeRoom(r);
+    return r;
+}
+export function activateRoom(id) {
+    const r = readRoom(id);
+    r.state = 'active';
+    r.saga = { phase: 'completed', step_index: 0 };
+    delete r.provisioning_detail;
+    r.activated_at = new Date().toISOString();
+    writeRoom(r);
+    return r;
+}
+export function closeRoom(id) {
+    const r = readRoom(id);
+    if (r.state === 'closed')
+        return r;
+    r.state = 'closed';
+    r.closed_at = new Date().toISOString();
+    writeRoom(r);
+    return r;
+}

package/dist/rooms-tasks/task-state.d.ts

@@ -0,0 +1,31 @@
+import type { TaskRecord, TaskState, TaskOrigin, TaskTemplateRef, TaskOutcome, TaskMemberRole } from './types.js';
+export declare const tasksDir: () => string;
+export declare class TaskStateError extends Error {
+}
+export interface CreateTaskInput {
+    title: string;
+    brief?: string;
+    brief_file?: string;
+    template?: TaskTemplateRef;
+    origin: TaskOrigin;
+    idempotency_key?: string;
+    start?: boolean;
+    room_id?: string;
+}
+export declare function createTask(input: CreateTaskInput): TaskRecord;
+export declare function getTask(id: string): TaskRecord;
+export declare function listTasks(filter?: {
+    state?: TaskState | TaskState[];
+}): TaskRecord[];
+export declare function findByIdempotencyKey(key: string): TaskRecord | undefined;
+export declare function startTask(id: string): TaskRecord;
+export declare function activateTask(id: string): TaskRecord;
+export declare function blockTask(id: string, reason: string): TaskRecord;
+export declare function unblockTask(id: string): TaskRecord;
+export declare function reviewTask(id: string): TaskRecord;
+export declare function completeTask(id: string, outcome?: TaskOutcome): TaskRecord;
+export declare function cancelTask(id: string): TaskRecord;
+export declare function failTask(id: string, error: string): TaskRecord;
+export declare function updateTaskRoom(id: string, roomId: string, roomIdentityCid: string): TaskRecord;
+export declare function updateTaskMembers(id: string, members: TaskMemberRole[]): TaskRecord;
+export declare function deleteTask(id: string): void;

package/dist/rooms-tasks/task-state.js

@@ -0,0 +1,173 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { stateRoot } from '../paths.js';
+import { TASK_TERMINAL_STATES, TASK_CANCELLABLE_STATES } from './types.js';
+export const tasksDir = () => join(stateRoot(), 'tasks');
+function taskPath(id) { return join(tasksDir(), `${id}.json`); }
+function generateTaskId() {
+    const ts = Date.now().toString(36).padStart(9, '0');
+    const rand = randomUUID().replace(/-/g, '').slice(0, 8);
+    return `${ts}${rand}`;
+}
+export class TaskStateError extends Error {
+}
+function readTask(id) {
+    const p = taskPath(id);
+    if (!existsSync(p))
+        throw new TaskStateError(`task not found: ${id}`);
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+function writeTask(record) {
+    mkdirSync(tasksDir(), { recursive: true });
+    replaceFileAtomically(taskPath(record.task_id), JSON.stringify(record, null, 2) + '\n');
+}
+// ── Lifecycle transitions ───────────────────────────────────────────────
+const VALID_TRANSITIONS = {
+    backlog: ['provisioning', 'cancelled'],
+    provisioning: ['active', 'failed', 'cancelled'],
+    active: ['review', 'failed', 'cancelled'],
+    review: ['done', 'failed', 'cancelled'],
+    done: [],
+    cancelled: [],
+    failed: [],
+};
+function assertTransition(from, to) {
+    if (!VALID_TRANSITIONS[from].includes(to))
+        throw new TaskStateError(`cannot transition from '${from}' to '${to}'`);
+}
+export function createTask(input) {
+    const key = input.idempotency_key ?? randomUUID();
+    const existing = findByIdempotencyKey(key);
+    if (existing)
+        return existing;
+    const state = input.start === false ? 'backlog' : 'provisioning';
+    const record = {
+        task_id: generateTaskId(),
+        title: input.title,
+        brief: input.brief,
+        brief_file: input.brief_file,
+        state,
+        template: input.template,
+        room_id: input.room_id,
+        member_roles: [],
+        origin: input.origin,
+        idempotency_key: key,
+        created_at: new Date().toISOString(),
+        started_at: state === 'provisioning' ? new Date().toISOString() : undefined,
+    };
+    writeTask(record);
+    return record;
+}
+export function getTask(id) { return readTask(id); }
+export function listTasks(filter) {
+    const dir = tasksDir();
+    if (!existsSync(dir))
+        return [];
+    const states = filter?.state
+        ? (Array.isArray(filter.state) ? filter.state : [filter.state])
+        : undefined;
+    const tasks = [];
+    for (const f of readdirSync(dir).filter(f => f.endsWith('.json'))) {
+        try {
+            const t = JSON.parse(readFileSync(join(dir, f), 'utf8'));
+            if (!states || states.includes(t.state))
+                tasks.push(t);
+        }
+        catch { /* corrupt file, skip */ }
+    }
+    return tasks.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+export function findByIdempotencyKey(key) {
+    return listTasks().find(t => t.idempotency_key === key);
+}
+export function startTask(id) {
+    const t = readTask(id);
+    assertTransition(t.state, 'provisioning');
+    t.state = 'provisioning';
+    t.started_at = new Date().toISOString();
+    writeTask(t);
+    return t;
+}
+export function activateTask(id) {
+    const t = readTask(id);
+    assertTransition(t.state, 'active');
+    t.state = 'active';
+    delete t.blocked;
+    writeTask(t);
+    return t;
+}
+export function blockTask(id, reason) {
+    const t = readTask(id);
+    if (TASK_TERMINAL_STATES.includes(t.state))
+        throw new TaskStateError(`cannot block a '${t.state}' task`);
+    t.blocked = { reason, at: new Date().toISOString() };
+    writeTask(t);
+    return t;
+}
+export function unblockTask(id) {
+    const t = readTask(id);
+    if (!t.blocked)
+        throw new TaskStateError('task is not blocked');
+    delete t.blocked;
+    writeTask(t);
+    return t;
+}
+export function reviewTask(id) {
+    const t = readTask(id);
+    assertTransition(t.state, 'review');
+    t.state = 'review';
+    delete t.blocked;
+    writeTask(t);
+    return t;
+}
+export function completeTask(id, outcome) {
+    const t = readTask(id);
+    assertTransition(t.state, 'done');
+    t.state = 'done';
+    t.ended_at = new Date().toISOString();
+    delete t.blocked;
+    if (outcome)
+        t.outcome = outcome;
+    writeTask(t);
+    return t;
+}
+export function cancelTask(id) {
+    const t = readTask(id);
+    if (!TASK_CANCELLABLE_STATES.includes(t.state))
+        throw new TaskStateError(`cannot cancel a '${t.state}' task`);
+    t.state = 'cancelled';
+    t.ended_at = new Date().toISOString();
+    delete t.blocked;
+    writeTask(t);
+    return t;
+}
+export function failTask(id, error) {
+    const t = readTask(id);
+    assertTransition(t.state, 'failed');
+    t.state = 'failed';
+    t.ended_at = new Date().toISOString();
+    t.outcome = { summary: error };
+    delete t.blocked;
+    writeTask(t);
+    return t;
+}
+export function updateTaskRoom(id, roomId, roomIdentityCid) {
+    const t = readTask(id);
+    t.room_id = roomId;
+    t.room_identity_cid = roomIdentityCid;
+    writeTask(t);
+    return t;
+}
+export function updateTaskMembers(id, members) {
+    const t = readTask(id);
+    t.member_roles = members;
+    writeTask(t);
+    return t;
+}
+export function deleteTask(id) {
+    const p = taskPath(id);
+    if (existsSync(p))
+        rmSync(p);
+}

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

@@ -0,0 +1,6 @@
+import type { TemplateDefinition, TemplateSnapshot } from './types.js';
+export declare const BUILTIN_TEMPLATES: readonly TemplateDefinition[];
+export declare function hashTemplate(t: TemplateDefinition): string;
+export declare function snapshotTemplate(t: TemplateDefinition): TemplateSnapshot;
+export declare function resolveTemplate(name: string, customTemplates: Record<string, TemplateDefinition>): TemplateDefinition | undefined;
+export declare function listTemplates(customTemplates: Record<string, TemplateDefinition>): TemplateDefinition[];

package/dist/rooms-tasks/templates.js

@@ -0,0 +1,80 @@
+import { createHash } from 'node:crypto';
+const DEVELOPMENT_TEAM = {
+    name: 'development-team',
+    version: 1,
+    builtin: true,
+    description: 'Four equal Developer peers: implement, review, test, and cross-validate',
+    room: { quiet_membership: false, anonymous: false },
+    contract: [
+        'Work in the room. Preserve evidence. Review independently before consensus.',
+        'Every material change needs independent review from another peer.',
+        'Peers reproduce, test, stress, criticize, and cross-validate each other\'s work.',
+        'Evidence and decisions are posted into the Room; detailed scratch work stays in role worklogs.',
+        'Completion requires the room\'s agreed acceptance criteria, not merely one agent declaring success.',
+    ].join('\n'),
+    members: [
+        { slot: 'developer', role: 'Developer', count: 4, role_ref: 'Developer' },
+    ],
+};
+const RESEARCH_DECISION = {
+    name: 'research-decision',
+    version: 1,
+    builtin: true,
+    description: 'Two Researchers, one Critic, one Synthesizer for evidence-based decisions',
+    room: { quiet_membership: false, anonymous: false },
+    contract: [
+        'Researchers gather independent evidence. Critic attacks assumptions and missing cases.',
+        'Synthesizer produces the final decision record with cited evidence, alternatives, and recommendation.',
+        'No code mutation is implied by this template.',
+        'Completion requires cited evidence, alternatives considered, and an explicit recommendation.',
+    ].join('\n'),
+    members: [
+        { slot: 'researcher', role: 'Researcher', count: 2, role_ref: 'Researcher' },
+        { slot: 'critic', role: 'Critic', count: 1, role_ref: 'Critic' },
+        { slot: 'synthesizer', role: 'Synthesizer', count: 1, role_ref: 'Synthesizer' },
+    ],
+};
+export const BUILTIN_TEMPLATES = [DEVELOPMENT_TEAM, RESEARCH_DECISION];
+export function hashTemplate(t) {
+    const canonical = JSON.stringify({
+        name: t.name, version: t.version, description: t.description,
+        room: t.room, contract: t.contract, members: t.members,
+    });
+    return createHash('sha256').update(canonical).digest('hex');
+}
+export function snapshotTemplate(t) {
+    return { ...t, content_hash: hashTemplate(t) };
+}
+export function resolveTemplate(name, customTemplates) {
+    const atIdx = name.lastIndexOf('@');
+    const baseName = atIdx > 0 ? name.slice(0, atIdx) : name;
+    const versionStr = atIdx > 0 ? name.slice(atIdx + 1) : undefined;
+    const version = versionStr ? parseInt(versionStr, 10) : undefined;
+    const custom = customTemplates[baseName];
+    if (custom) {
+        if (version !== undefined && custom.version !== version)
+            return undefined;
+        return custom;
+    }
+    const builtin = BUILTIN_TEMPLATES.find(b => b.name === baseName);
+    if (builtin) {
+        if (version !== undefined && builtin.version !== version)
+            return undefined;
+        return builtin;
+    }
+    return undefined;
+}
+export function listTemplates(customTemplates) {
+    const result = [];
+    const overridden = new Set();
+    for (const [name, t] of Object.entries(customTemplates)) {
+        result.push({ ...t, name });
+        if (BUILTIN_TEMPLATES.some(b => b.name === name))
+            overridden.add(name);
+    }
+    for (const b of BUILTIN_TEMPLATES) {
+        if (!overridden.has(b.name))
+            result.push(b);
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+}

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

@@ -0,0 +1,153 @@
+/**
+ * Rooms & Tasks domain types for ours-fleet.
+ *
+ * Task and Room are Fleet orchestration records. Cowork owns room content,
+ * membership, and archive. Messenger Server owns owner presentation.
+ * Fleet stores only IDs, CIDs, orchestration state, and saga cursors.
+ */
+export type TaskState = 'backlog' | 'provisioning' | 'active' | 'review' | 'done' | 'cancelled' | 'failed';
+export declare const TASK_TERMINAL_STATES: readonly TaskState[];
+export declare const TASK_CANCELLABLE_STATES: readonly TaskState[];
+export interface TaskBlocked {
+    reason: string;
+    at: string;
+}
+export interface TaskTemplateRef {
+    name: string;
+    version: number;
+    content_hash: string;
+}
+export interface TaskMemberRole {
+    name: string;
+    identity_cid: string;
+    slot: string;
+    cowork_role: string;
+}
+export interface TaskOrigin {
+    type: 'cli' | 'owner_channel';
+    owner_cid?: string;
+}
+export interface TaskOutcome {
+    summary: string;
+    artifacts?: string[];
+}
+export interface TaskRecord {
+    task_id: string;
+    title: string;
+    brief?: string;
+    brief_file?: string;
+    state: TaskState;
+    blocked?: TaskBlocked;
+    template?: TaskTemplateRef;
+    room_id?: string;
+    room_identity_cid?: string;
+    member_roles: TaskMemberRole[];
+    origin: TaskOrigin;
+    idempotency_key: string;
+    created_at: string;
+    started_at?: string;
+    ended_at?: string;
+    outcome?: TaskOutcome;
+}
+export type RoomOrchestrationState = 'provisioning' | 'active' | 'closing' | 'closed';
+export type SagaPhase = 'persist_intent' | 'create_room' | 'attach_owner' | 'create_members' | 'join_role_groups' | 'wait_seats' | 'launch_work' | 'activate' | 'completed' | 'failed';
+export interface SagaCursor {
+    phase: SagaPhase;
+    step_index: number;
+    error?: string;
+    recovery_hint?: string;
+}
+export type ProvisioningDetail = 'waiting_cowork' | 'waiting_owner_invite' | 'owner_cid_mismatch' | 'member_failed' | 'waiting_seats' | 'uncertain';
+export interface RoomMemberSeat {
+    role_name: string;
+    identity_cid: string;
+    slot: string;
+    cowork_role: string;
+    seat_state: 'pending' | 'active' | 'removed';
+}
+export interface RoomOrchestrationRecord {
+    room_id: string;
+    room_identity_cid?: string;
+    room_name: string;
+    task_id?: string;
+    template_snapshot?: TemplateSnapshot;
+    saga: SagaCursor;
+    provisioning_detail?: ProvisioningDetail;
+    owner_seat_cid?: string;
+    owner_invite_fingerprint?: string;
+    member_seats: RoomMemberSeat[];
+    state: RoomOrchestrationState;
+    created_at: string;
+    activated_at?: string;
+    closed_at?: string;
+}
+export interface TemplateMemberSlot {
+    slot: string;
+    role: string;
+    count: number;
+    role_ref: string;
+    overrides?: TemplateRoleOverrides;
+}
+export interface TemplateRoleOverrides {
+    harness?: string;
+    model?: string;
+    model_chain?: string[];
+    permissions?: Record<string, unknown>;
+    isolation?: Record<string, unknown>;
+    cwd?: string;
+    env?: Record<string, string>;
+    persona?: string;
+    mission?: string;
+}
+export interface TemplateRoomConfig {
+    quiet_membership?: boolean;
+    anonymous?: boolean;
+}
+export interface TemplateDefinition {
+    name: string;
+    version: number;
+    description: string;
+    builtin?: boolean;
+    room?: TemplateRoomConfig;
+    contract?: string;
+    members: TemplateMemberSlot[];
+}
+export interface TemplateSnapshot extends TemplateDefinition {
+    content_hash: string;
+}
+export interface RoomsOwnerConfig {
+    provider: string;
+    public_invite?: string;
+    public_invite_file?: string;
+    expected_cid: string;
+    role: string;
+}
+export interface RoomsCoworkConfig {
+    config?: string;
+}
+export interface RoomsDefaults {
+    template?: string;
+    attach_owner?: boolean;
+    close_when_task_done?: boolean;
+}
+export interface RoomsConfig {
+    provider: string;
+    cowork?: RoomsCoworkConfig;
+    owner: RoomsOwnerConfig;
+    defaults?: RoomsDefaults;
+}
+export interface TasksConfig {
+    default_room_template?: string;
+    create_mode?: 'start' | 'backlog';
+    close_room_on_done?: boolean;
+    retain_completed_for?: string;
+}
+export type RoomTemplatesConfig = Record<string, TemplateDefinition>;
+export declare const ROOMS_KEYS: readonly ["provider", "cowork", "owner", "defaults"];
+export declare const ROOMS_OWNER_KEYS: readonly ["provider", "public_invite", "public_invite_file", "expected_cid", "role"];
+export declare const ROOMS_COWORK_KEYS: readonly ["config"];
+export declare const ROOMS_DEFAULTS_KEYS: readonly ["template", "attach_owner", "close_when_task_done"];
+export declare const TASKS_KEYS: readonly ["default_room_template", "create_mode", "close_room_on_done", "retain_completed_for"];
+export declare const TEMPLATE_KEYS: readonly ["version", "description", "room", "contract", "members", "override_builtin"];
+export declare const TEMPLATE_MEMBER_KEYS: readonly ["slot", "role", "count", "role_ref", "overrides"];
+export declare const TEMPLATE_OVERRIDE_KEYS: readonly ["harness", "model", "model_chain", "permissions", "isolation", "cwd", "env", "persona", "mission"];

package/dist/rooms-tasks/types.js

@@ -0,0 +1,20 @@
+/**
+ * Rooms & Tasks domain types for ours-fleet.
+ *
+ * Task and Room are Fleet orchestration records. Cowork owns room content,
+ * membership, and archive. Messenger Server owns owner presentation.
+ * Fleet stores only IDs, CIDs, orchestration state, and saga cursors.
+ */
+export const TASK_TERMINAL_STATES = ['done', 'cancelled', 'failed'];
+export const TASK_CANCELLABLE_STATES = ['backlog', 'provisioning', 'active', 'review'];
+// ── Validation keys ─────────────────────────────────────────────────────
+export const ROOMS_KEYS = ['provider', 'cowork', 'owner', 'defaults'];
+export const ROOMS_OWNER_KEYS = ['provider', 'public_invite', 'public_invite_file', 'expected_cid', 'role'];
+export const ROOMS_COWORK_KEYS = ['config'];
+export const ROOMS_DEFAULTS_KEYS = ['template', 'attach_owner', 'close_when_task_done'];
+export const TASKS_KEYS = ['default_room_template', 'create_mode', 'close_room_on_done', 'retain_completed_for'];
+export const TEMPLATE_KEYS = ['version', 'description', 'room', 'contract', 'members', 'override_builtin'];
+export const TEMPLATE_MEMBER_KEYS = ['slot', 'role', 'count', 'role_ref', 'overrides'];
+export const TEMPLATE_OVERRIDE_KEYS = [
+    'harness', 'model', 'model_chain', 'permissions', 'isolation', 'cwd', 'env', 'persona', 'mission',
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.19.0-nightly.1",
+  "version": "0.19.0-nightly.3",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",