@ours.network/fleet 0.18.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/dist/runner.d.ts

@@ -35,15 +35,6 @@ export interface RunnerDeps {
 }
 /** Environment injected only into the managed harness process. */
 export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
-/**
- * The environment a managed harness child actually receives, checked at the one
- * point where it is composed. `role.env` deliberately wins over harness prep,
- * which is exactly how a stale fleet-wide model pin used to outrank the model
- * the role was spawned with — so the model pin is verified here rather than
- * trusted, and a disagreement stops the launch instead of being reported as a
- * success (see src/model-env.ts).
- */
-export declare function harnessChildEnv(role: ResolvedRole, launchEnv: Record<string, string> | undefined, stateDir: string): Record<string, string>;
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the
@@ -70,23 +61,6 @@ export declare function readExitRecord(path: string): ExitRecord | null;
 export declare const RESTART_LEDGER_FILE = ".restart-ledger.json";
 /** Consecutive immediate failures tolerated before the agent is held down. */
 export declare const RESTART_FAIL_THRESHOLD = 5;
-/**
- * How the previous supervisor process ended.
- *
- * `abrupt` is the case the ledger used to miss entirely: an OOM-kill or any
- * other external signal takes the supervisor down before it can write anything,
- * the service manager restarts the unit, and every durable indicator still
- * describes the run that died. A health check reading them reported "no
- * restarts" for a role that had died and come back.
- */
-export interface TerminationRecord {
-    class: 'clean' | 'abrupt' | 'unknown';
-    detail: string;
-    /** When the SURVIVING process observed it, not when it happened. */
-    observedAt: string;
-    /** Start time of the run that ended, when it was recorded. */
-    runStartedAt?: string;
-}
 export interface RestartLedger {
     version: 1;
     consecutiveImmediateFailures: number;
@@ -98,29 +72,7 @@ export interface RestartLedger {
     updatedAt: string;
     /** When the circuit opened, for the held-down status line. */
     openedAt?: string;
-    /** How the previous supervisor process ended, including abnormal exits. */
-    lastTermination?: TerminationRecord;
-    /** Supervisor processes that died without closing their run marker. */
-    abruptTerminations?: number;
-    /** Start of the supervisor run that owns this state directory now. */
-    supervisorStartedAt?: string;
 }
-/**
- * Carried across a supervisor process's life so its successor can tell an
- * orderly exit from a kill. Present on disk == "a supervisor believed it was
- * running"; the next start finding one that is not its own is proof the
- * previous process died without getting to write anything.
- */
-export declare const RUN_MARKER_FILE = ".supervisor-run.json";
-/**
- * Claim this state directory for the current supervisor process and report how
- * the previous one ended. Runs BEFORE the first attempt, which is the whole
- * point: after an abrupt kill nothing else writes until an attempt finishes,
- * and an attempt can take minutes.
- */
-export declare function claimSupervisorRun(dir: string, startedAt: string, pid?: number): TerminationRecord;
-/** Orderly exit: the successor must not read this run as a kill. */
-export declare function releaseSupervisorRun(dir: string): void;
 /** Bounded exponential backoff for the nth consecutive immediate failure. */
 export declare function backoffFor(consecutiveFailures: number): number;
 /** Read a role's restart ledger; a missing or corrupt one starts clean. */