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

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.2",
   "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",