@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.3

package/dist/rooms-tasks/config.js

@@ -1,7 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, TEMPLATE_OVERRIDE_KEYS as TOK, } from './types.js';
+import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, } from './types.js';
 import { BUILTIN_TEMPLATES } from './templates.js';
+import { isSensitiveConfigKey } from '../sensitive-config.js';
 const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 const CID_RE = /^[0-9a-fA-F]{64}$/;
 export class RoomsTasksConfigError extends Error {
@@ -136,19 +137,33 @@ export function validateRoomTemplatesConfig(raw, path) {
                 throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role: required string`);
             if (!Number.isInteger(m.count) || m.count < 1)
                 throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].count: required positive integer`);
-            if (!m.role_ref || typeof m.role_ref !== 'string')
-                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role_ref: required string`);
-            if (m.overrides !== undefined) {
-                if (!isPlainObject(m.overrides))
-                    throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].overrides: must be a mapping`);
-                rejectUnknown(m.overrides, TOK, path, `room_templates.${name}.members[${i}].overrides`);
+            if (!isPlainObject(m.agent))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: required mapping`);
+            const agentKeys = Object.keys(m.agent);
+            const isRef = agentKeys.length === 1 && typeof m.agent.ref === 'string';
+            const isDefinition = agentKeys.includes('role') && agentKeys.includes('brain');
+            if (!isRef && !isDefinition)
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: must be {ref} or canonical {role, brain, ...}`);
+            const containsSensitive = (value) => Array.isArray(value)
+                ? value.some(containsSensitive)
+                : Boolean(value && typeof value === 'object' && Object.entries(value)
+                    .some(([key, child]) => isSensitiveConfigKey(key) || containsSensitive(child)));
+            if (isDefinition && containsSensitive(m.agent))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: inline sensitive configuration cannot be persisted; use references`);
+            if (isDefinition) {
+                const definition = m.agent;
+                const brain = isPlainObject(definition.brain) && isPlainObject(definition.brain.inline)
+                    ? definition.brain.inline : undefined;
+                if (definition.env !== undefined || definition.owner_channel !== undefined
+                    || definition.auth_proxy !== undefined || brain?.harness_options !== undefined
+                    || brain?.session_options !== undefined)
+                    throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: secret-capable inline fields cannot be persisted; use references`);
             }
             return {
                 slot: m.slot,
                 role: m.role,
                 count: m.count,
-                role_ref: m.role_ref,
-                overrides: m.overrides,
+                agent: structuredClone(m.agent),
             };
         });
         let room;

package/dist/rooms-tasks/provision.js

@@ -1,10 +1,10 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { parse } from 'yaml';
 import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, activateRoom, getRoomRecord, } from './room-state.js';
 import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
 import { spawnTemp } from '../spawn.js';
-import { findRole } from '../config.js';
+import { findRole, loadConfig } from '../config.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from '../fleet-proxy.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
@@ -21,6 +21,26 @@ export function getBinPath() {
         return process.argv[1];
     }
 }
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+function launchDefinition(definition) {
+    const selectionEvidence = (selection) => 'ref' in selection ? { kind: 'ref', id: selection.ref } : { kind: 'inline' };
+    return {
+        projection: {
+            brain: selectionEvidence(definition.brain), role: selectionEvidence(definition.role),
+            operationalFields: Object.keys(definition)
+                .filter(key => key !== 'brain' && key !== 'role').sort(),
+        },
+        fingerprint: createHash('sha256').update(canonicalJson(definition)).digest('hex'),
+    };
+}
 async function spawnRoomMember(options, binPath) {
     const stateDir = process.env[FLEET_PROXY_STATE_DIR_ENV];
     if (!stateDir)
@@ -52,28 +72,31 @@ function expandMembers(template, prefix) {
                 name: `${prefix}-${slot.slot}-${i}`,
                 slot: slot.slot,
                 coworkRole: slot.role,
-                roleRef: slot.role_ref,
-                overrides: slot.overrides,
+                agent: structuredClone(slot.agent),
             });
         }
     }
     return result;
 }
 function settingsFor(member, cfg) {
-    let refRole;
-    try {
-        refRole = findRole(cfg, member.roleRef);
+    if (!('ref' in member.agent)) {
+        const role = member.agent.role;
+        if (cfg.files[0] && existsSync(cfg.files[0]) && statSync(cfg.files[0]).isFile())
+            loadConfig(cfg.files[0], { additionalAgent: {
+                    id: `RoomPreflight${member.name.replace(/[^A-Za-z0-9_-]/g, '')}`.slice(0, 64),
+                    definition: member.agent,
+                } });
+        return { definition: structuredClone(member.agent),
+            ...('inline' in role && typeof role.inline.persona === 'string'
+                ? { persona: role.inline.persona } : {}) };
     }
-    catch { /* no ref role */ }
-    const permissions = member.overrides?.permissions;
+    const refRole = findRole(cfg, member.agent.ref);
+    const definition = cfg.agentDefinitions?.[member.agent.ref];
+    if (!definition)
+        throw new Error(`Agent '${member.agent.ref}' has no canonical definition`);
     return {
-        model: member.overrides?.model ?? refRole?.model,
-        harness: member.overrides?.harness ?? refRole?.harness,
-        cwd: member.overrides?.cwd ?? refRole?.cwd,
-        persona: member.overrides?.persona ?? refRole?.persona,
-        approval: permissions?.approval,
-        filesystem: permissions?.filesystem,
-        unattended: permissions?.unattended,
+        definition: structuredClone(definition),
+        persona: refRole.persona,
     };
 }
 function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid) {
@@ -104,13 +127,11 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
         const role = parse(readFileSync(`${dir}/role.yaml`, 'utf8'));
         const startup = role.roomMemberStartup;
         return role.identity === member.name
-            && typeof role.mission === 'string'
-            && sha256Text(role.mission) === taskSha
             && startup?.room_id === roomId
             && startup.room_identity_cid === roomIdentityCid
             && startup.identity_name === member.name
             && startup.role === member.coworkRole
-            && startup.task === role.mission
+            && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
             && typeof startup.invite === 'string'
             && startup.invite.length > 0;
@@ -199,10 +220,13 @@ async function launchMember(input) {
     let effectiveActionId = actionId;
     const attempt = (seat.launch?.attempt ?? 0) + 1;
     const taskSha = sha256Text(startup.task);
+    const effectiveAgentDefinition = structuredClone(settings.definition);
+    const { projection: agentDefinition, fingerprint: agentFingerprint } = launchDefinition(effectiveAgentDefinition);
     const proxyCaller = process.env[FLEET_PROXY_STATE_DIR_ENV]
         ? process.env[FLEET_PROXY_CALLER_ENV] : undefined;
     updateMemberStartup(provision.roomId, member.name, { launch: {
             state: 'intent', attempt, action_id: actionId, mission_sha256: taskSha,
+            agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
             ...(proxyCaller ? { caller_role: proxyCaller } : {}),
             updated_at: new Date().toISOString(),
         } });
@@ -211,13 +235,7 @@ async function launchMember(input) {
             name: member.name,
             temp: true,
             identity: member.name,
-            mission: startup.task,
-            model: settings.model,
-            harness: settings.harness,
-            cwd: settings.cwd,
-            approval: settings.approval,
-            filesystem: settings.filesystem,
-            unattended: settings.unattended,
+            agentDefinition: settings.definition,
             surface: 'agent',
             creationActionId: actionId,
             roomMemberStartup: startup,
@@ -227,7 +245,8 @@ async function launchMember(input) {
         if (launched.creationActionId !== actionId) {
             updateMemberStartup(provision.roomId, member.name, { launch: {
                     state: 'intent', attempt, action_id: launched.creationActionId,
-                    mission_sha256: taskSha, updated_at: new Date().toISOString(),
+                    mission_sha256: taskSha, agent_definition: agentDefinition,
+                    agent_fingerprint: agentFingerprint, updated_at: new Date().toISOString(),
                     ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 } });
         }
@@ -237,6 +256,7 @@ async function launchMember(input) {
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'launched', attempt, action_id: launched.creationActionId, mission_sha256: taskSha,
+                agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 launch_id: supervisor.launchId, updated_at: new Date().toISOString(),
             } });
@@ -244,6 +264,7 @@ async function launchMember(input) {
     catch (error) {
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'failed', attempt, action_id: effectiveActionId, mission_sha256: taskSha,
+                agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 ...(proxyCaller ? { caller_role: proxyCaller } : {}),
                 updated_at: new Date().toISOString(),
                 error: error instanceof Error ? error.message : String(error),
@@ -289,6 +310,8 @@ export async function provisionMembers(input) {
     const { cfg, cowork, roomId, taskId, template } = input;
     const prefix = taskId ? shortId(taskId) : `room-${shortId(roomId)}`;
     const members = expandMembers(template, prefix);
+    // Resolve every Agent before persisting launch intent or touching Cowork membership.
+    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
     const existing = getRoomRecord(roomId);
     if (!existing?.room_identity_cid)
         throw new Error(`room ${roomId} has no pinned room identity CID`);
@@ -299,15 +322,27 @@ export async function provisionMembers(input) {
         && members.every(member => persistedNames.has(member.name));
     if (!resuming) {
         advanceSaga(roomId, 'create_members', 3);
-        updateMemberSeats(roomId, members.map(member => ({
-            role_name: member.name,
-            slot: member.slot,
-            cowork_role: member.coworkRole,
-            seat_state: 'pending',
-            launch: { state: 'pending', attempt: 0, updated_at: new Date().toISOString() },
-        })));
+        updateMemberSeats(roomId, members.map(member => {
+            const evidence = launchDefinition(settings.get(member.name).definition);
+            return ({
+                role_name: member.name,
+                slot: member.slot,
+                cowork_role: member.coworkRole,
+                seat_state: 'pending',
+                launch: { state: 'pending', attempt: 0,
+                    agent_definition: evidence.projection, agent_fingerprint: evidence.fingerprint,
+                    updated_at: new Date().toISOString() },
+            });
+        }));
+    }
+    else {
+        for (const member of members) {
+            const seat = existing.member_seats.find(candidate => candidate.role_name === member.name);
+            const evidence = launchDefinition(settings.get(member.name).definition);
+            if (!seat.launch?.agent_fingerprint || seat.launch.agent_fingerprint !== evidence.fingerprint)
+                throw new Error(`Agent definition drift for ${member.name}; durable launch intent does not match current configuration`);
+        }
     }
-    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
     const tasks = new Map(members.map(member => [member.name, roomTask(input, member, settings.get(member.name), members, roomIdentityCid, ownerSeatCid)]));
     const policy = {
         timeoutMs: input.startupWait?.timeoutMs ?? 60_000,

package/dist/rooms-tasks/templates.js

@@ -12,9 +12,9 @@ const TEAM = {
         'Completion requires tester sign-off.',
     ].join('\n'),
     members: [
-        { slot: 'architect', role: 'Architect', count: 1, role_ref: 'Architect' },
-        { slot: 'developer', role: 'Developer', count: 1, role_ref: 'Developer' },
-        { slot: 'tester', role: 'Tester', count: 1, role_ref: 'Tester' },
+        { slot: 'architect', role: 'Architect', count: 1, agent: { ref: 'Architect' } },
+        { slot: 'developer', role: 'Developer', count: 1, agent: { ref: 'Developer' } },
+        { slot: 'tester', role: 'Tester', count: 1, agent: { ref: 'Tester' } },
     ],
 };
 const PAIR = {
@@ -30,8 +30,8 @@ const PAIR = {
         'Completion requires joint sign-off.',
     ].join('\n'),
     members: [
-        { slot: 'secretary', role: 'Secretary', count: 1, role_ref: 'Secretary' },
-        { slot: 'critic', role: 'Critic', count: 1, role_ref: 'Critic' },
+        { slot: 'secretary', role: 'Secretary', count: 1, agent: { ref: 'Secretary' } },
+        { slot: 'critic', role: 'Critic', count: 1, agent: { ref: 'Critic' } },
     ],
 };
 const SINGLE = {
@@ -45,7 +45,7 @@ const SINGLE = {
         'Owner reviews and approves completion.',
     ].join('\n'),
     members: [
-        { slot: 'agent', role: 'Agent', count: 1, role_ref: 'Agent' },
+        { slot: 'agent', role: 'Agent', count: 1, agent: { ref: 'Agent' } },
     ],
 };
 export const BUILTIN_TEMPLATES = [TEAM, PAIR, SINGLE];

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

@@ -100,6 +100,9 @@ export interface RoomMemberLaunchState {
     /** Expected authenticated proxy caller while adopting a post-spawn crash. */
     caller_role?: string;
     mission_sha256?: string;
+    /** Redacted, deterministic effective Agent launch definition retained for retry inspection. */
+    agent_definition?: Record<string, unknown>;
+    agent_fingerprint?: string;
     launch_id?: string;
     updated_at: string;
     error?: string;
@@ -189,19 +192,10 @@ 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;
+    /** Canonical Agent definition, or stable reference to a declared Agent. */
+    agent: import('../config.js').AgentDefinition | {
+        ref: string;
+    };
 }
 export interface TemplateRoomConfig {
     quiet_membership?: boolean;
@@ -252,5 +246,4 @@ 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"];
+export declare const TEMPLATE_MEMBER_KEYS: readonly ["slot", "role", "count", "agent"];

package/dist/rooms-tasks/types.js

@@ -14,7 +14,4 @@ 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',
-];
+export const TEMPLATE_MEMBER_KEYS = ['slot', 'role', 'count', 'agent'];

package/dist/spawn.d.ts

@@ -1,5 +1,5 @@
 import type { IsolationConfig } from './isolation/types.js';
-import { type ApprovalMode, type FilesystemMode, type ResolvedRole, type RoleConfig, type MonitorConfig, type SessionBackendId, type UnattendedMode, type RoomMemberStartup } from './config.js';
+import { type ApprovalMode, type FilesystemMode, type ResolvedRole, type MonitorConfig, type UnattendedMode, type RoomMemberStartup, type AgentDefinition, type AgentSelection } from './config.js';
 import { type OpsDeps } from './ops.js';
 import { type CreationDeps, type CreationProvenance } from './creation.js';
 import './harness/claude-code.js';
@@ -13,34 +13,18 @@ export declare let lastProvenance: CreationProvenance | undefined;
 export interface SpawnOpts {
     name: string;
     temp?: boolean;
-    harness?: string;
-    session?: SessionBackendId;
-    mission?: string;
-    missionFile?: string;
+    brain?: AgentSelection;
+    role?: AgentSelection;
+    /** Trusted canonical definition used by room provisioning; never a second schema. */
+    agentDefinition?: AgentDefinition;
     identity?: string;
     cwd?: string;
     coordinator?: string;
-    /** null explicitly selects the harness default; undefined retains normal fleet inheritance. */
-    model?: string | null;
-    permissionMode?: string;
     approval?: ApprovalMode;
     filesystem?: FilesystemMode;
     unattended?: UnattendedMode;
-    sandbox?: string;
-    profile?: string;
-    launcher?: string;
-    search?: boolean;
-    codexConfig?: Record<string, string | number | boolean>;
-    reasoningEffort?: string | null;
-    addDirs?: string[];
-    monitor?: boolean;
     /** Typed external monitor configuration used by trusted creation surfaces. */
     monitorConfig?: Partial<MonitorConfig>;
-    bioFile?: string;
-    personaFile?: string;
-    /** Inline profile values for trusted typed callers such as the local web service. */
-    bio?: string;
-    persona?: string;
     /** Internal, non-sensitive provenance correlation for typed presentation layers. */
     surface?: 'cli' | 'web' | 'agent';
     creationActionId?: string;
@@ -61,12 +45,7 @@ export interface SpawnOpts {
     dryRun?: boolean;
     json?: boolean;
 }
-export declare function profileValues(o: SpawnOpts): {
-    bio?: string;
-    persona?: string;
-};
-/** Pure option-to-role mapping shared by CLI and application services. */
-export declare function buildRoleConfig(o: SpawnOpts, defaultHarness?: string): RoleConfig;
+export declare function agentDefinitionFromSpawn(o: SpawnOpts): AgentDefinition;
 /**
  * Read and validate an `--isolation-file`. The file is the existing
  * `isolation:` mapping and nothing else — the same schema, the same validator
@@ -78,8 +57,6 @@ export declare function buildRoleConfig(o: SpawnOpts, defaultHarness?: string):
  */
 export declare function readIsolationFile(path: string): IsolationConfig;
 export declare function validateSpawnOpts(o: SpawnOpts): void;
-/** Read mission text without trimming or newline rewriting. */
-export declare function readMissionFile(path: string): string;
 /** The ours identity a spawn will bind: explicit, else the role name. */
 export declare const effectiveIdentity: (o: SpawnOpts) => string;
 export interface SpawnDryRun {
@@ -88,8 +65,6 @@ export interface SpawnDryRun {
     roleDocument: Record<string, unknown>;
     resolvedRole: ResolvedRole;
 }
-/** Bare Agent document written by v2 spawn: inline Role × inline Brain + operations. */
-export declare function buildAgentDocument(raw: RoleConfig): Record<string, unknown>;
 /**
  * Validate and resolve a spawn without reserving names, contacting the daemon,
  * or writing state. Collision checks are necessarily a point-in-time snapshot.