@ours.network/fleet 1.1.0-nightly.1 → 1.1.0-nightly.11

package/dist/application/role-creation-service.js

@@ -1,16 +1,15 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { isAbsolute, relative } from 'node:path';
-import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolveRoleModel, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
+import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
 import { daemonIdentityProvisioner, } from '../creation.js';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
-import { buildRoleConfig, spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
+import { spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
 import { FleetError, normalizeError } from './errors.js';
 import { inheritCallerSpawnDefaults } from '../fleet-proxy.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { effectiveRoleModel } from '../model-env.js';
-import { claudeModelCatalog, codexModelCatalog, } from './model-catalog.js';
 const canonical = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
@@ -62,6 +61,16 @@ export class RoleCreationService {
         const creationActionId = randomUUID();
         plan.options.creationActionId = creationActionId;
         const statePath = await this.launchSync(plan.options);
+        const selectionSummary = (kind) => {
+            const value = plan.options[kind];
+            const provenance = plan.inherited.includes(kind) ? 'inherited' : 'explicit';
+            if (!value)
+                return `unresolved (${provenance})`;
+            if ('ref' in value)
+                return `ref:${value.ref} (${provenance})`;
+            const fingerprint = hash(value.inline).slice(0, 16);
+            return `inline:sha256:${fingerprint} (${provenance})`;
+        };
         return {
             caller: plan.caller, role: plan.options.name,
             lifetime: plan.options.temp ? 'temporary' : 'permanent', statePath,
@@ -70,6 +79,7 @@ export class RoleCreationService {
             monitor: { mode: plan.preview.resolvedRole.monitor.mode, interrupt: plan.preview.resolvedRole.monitor.interrupt },
             permissionMode: effectivePermissionMode(plan.preview.resolvedRole), inherited: plan.inherited,
             creationActionId,
+            brainSummary: selectionSummary('brain'), roleSummary: selectionSummary('role'),
         };
     }
     launchSync(options, creation) {
@@ -80,47 +90,16 @@ export class RoleCreationService {
     async capabilities() {
         const reasons = [];
         let defaults = {};
-        let roles = [];
         try {
             const config = loadConfig(this.options.configPath);
             defaults = config.defaults;
-            roles = config.roles;
         }
         catch (error) {
             reasons.push(`configuration is invalid: ${error.message}`);
         }
-        const modelsFor = (harness, catalog) => {
-            const configured = roles.filter(role => role.harness === harness)
-                .flatMap(role => [role.model, ...(role.model_chain ?? [])])
-                .filter((model) => Boolean(model));
-            const inherited = resolveRoleModel(undefined, harness, defaults);
-            const configuredOptions = [...new Set([...(inherited ? [inherited] : []), ...configured])]
-                .filter(id => !catalog.models.some(model => model.id === id))
-                .map(id => ({ id, label: `${id} (configured)`, reasoningEfforts: [], source: 'fleet-config' }));
-            const modelOptions = [...configuredOptions, ...catalog.models];
-            return { modelOptions, models: modelOptions.map(model => model.id) };
-        };
-        const codexCatalog = this.options.modelCatalogs?.codex?.() ?? codexModelCatalog();
-        const claudeCatalog = this.options.modelCatalogs?.['claude-code']?.() ?? claudeModelCatalog();
-        const codexModels = modelsFor('codex', codexCatalog);
-        const claudeModels = modelsFor('claude-code', claudeCatalog);
         return {
             available: reasons.length === 0,
             reasons,
-            harnesses: [
-                {
-                    id: 'codex', available: true, sessions: ['acp'],
-                    defaultModel: resolveRoleModel(undefined, 'codex', defaults),
-                    ...codexModels, catalogSource: 'codex-runtime-catalog', customModelAllowed: true,
-                    warnings: codexCatalog.warnings,
-                },
-                {
-                    id: 'claude-code', available: true, sessions: ['acp'],
-                    defaultModel: resolveRoleModel(undefined, 'claude-code', defaults),
-                    ...claudeModels, catalogSource: 'claude-adapter-2.1', customModelAllowed: true,
-                    warnings: claudeCatalog.warnings,
-                },
-            ],
             lifetimes: ['permanent', 'temporary'],
             identityBootstrap: {
                 mode: 'current-fleet-first-boot',
@@ -144,14 +123,12 @@ export class RoleCreationService {
         const defaults = cfg.defaults;
         const opts = this.spawnOptions(request);
         validateSpawnOpts(opts);
-        buildRoleConfig(opts, defaults.harness);
+        const resolved = spawnDryRun(opts).resolvedRole;
         const cwd = request.cwd ? this.resolveCwd(request.cwd) : undefined;
         const effective = {
             name: request.name, identity: request.name,
-            harness: request.harness ?? defaults.harness ?? 'claude-code',
-            session: request.session ?? defaults.session ?? 'acp',
-            model: resolveRoleModel(request.model, request.harness, defaults),
-            reasoningEffort: request.reasoningEffort ?? undefined,
+            harness: resolved.harness, session: resolved.session, model: resolved.model,
+            reasoningEffort: resolved.effort,
             cwd, lifetime: request.lifetime,
             permissions: resolvePermissions(defaults.permissions, request.permissions),
             monitor: resolveMonitorConfig(defaults.monitor, request.monitor),
@@ -183,9 +160,7 @@ export class RoleCreationService {
         if (existingIdentity === 'unknown' && !request.unverifiedIdentityAcknowledged)
             prerequisites.push('confirm creation with an unverified identity preflight');
         const provenance = {
-            harness: 'request', session: 'request', identity: 'built-in',
-            model: request.model !== undefined ? 'request'
-                : resolveRoleModel(undefined, request.harness, defaults) ? 'fleet-default' : 'built-in',
+            brain: 'request', role: 'request', identity: 'built-in',
             cwd: request.cwd ? 'request' : 'built-in', permissions: 'request',
             monitor: request.monitor ? 'request' : defaults.monitor ? 'fleet-default' : 'built-in',
         };
@@ -296,8 +271,8 @@ export class RoleCreationService {
     }
     validate(input) {
         const allowed = new Set([
-            'name', 'harness', 'model', 'reasoningEffort', 'session', 'cwd', 'lifetime', 'mission',
-            'coordinator', 'permissions', 'bio', 'persona', 'monitor', 'openAfterCreate',
+            'name', 'brain', 'role', 'cwd', 'lifetime',
+            'coordinator', 'permissions', 'monitor', 'openAfterCreate',
             'highRiskAcknowledged', 'reuseExistingIdentityAcknowledged',
             'unverifiedIdentityAcknowledged',
         ]);
@@ -307,20 +282,11 @@ export class RoleCreationService {
             throw new FleetError('invalid_request', `unsupported web creation field: ${unsupported[0]}`);
         if (!ROLE_NAME_RE.test(input.name))
             throw new FleetError('invalid_request', 'invalid role name');
-        if (!['codex', 'claude-code'].includes(input.harness))
-            throw new FleetError('invalid_request', 'unsupported harness');
-        if (input.session !== 'acp')
-            throw new FleetError('invalid_request', 'unsupported session backend');
+        if (!input.brain || !input.role)
+            throw new FleetError('invalid_request', 'brain and role selections are required');
         if (!['permanent', 'temporary'].includes(input.lifetime))
             throw new FleetError('invalid_request', 'unsupported lifetime');
-        bounded(input.model ?? undefined, 'model', 128);
-        bounded(input.reasoningEffort ?? undefined, 'reasoning effort', 16);
-        if (input.reasoningEffort != null && !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(input.reasoningEffort))
-            throw new FleetError('invalid_request', 'unsupported reasoning effort');
-        bounded(input.mission, 'mission', 4_096);
         bounded(input.coordinator, 'coordinator', 128);
-        bounded(input.bio, 'bio', 8_192);
-        bounded(input.persona, 'persona', 16_384);
         resolvePermissions(undefined, input.permissions);
         if (input.monitor) {
             const problems = validateMonitorConfig(input.monitor);
@@ -330,10 +296,8 @@ export class RoleCreationService {
                 throw new FleetError('invalid_request', 'web creation supports monitor.inject=notification only');
         }
         return {
-            ...input, model: input.model === null ? null : input.model?.trim() || undefined,
-            reasoningEffort: input.reasoningEffort === null ? null : input.reasoningEffort?.trim() || undefined,
-            mission: input.mission?.trim() || undefined, coordinator: input.coordinator?.trim() || undefined,
-            bio: input.bio?.trim() || undefined, persona: input.persona?.trim() || undefined,
+            ...input, brain: structuredClone(input.brain), role: structuredClone(input.role),
+            coordinator: input.coordinator?.trim() || undefined,
             monitor: input.monitor ? structuredClone(input.monitor) : undefined,
         };
     }
@@ -360,12 +324,10 @@ export class RoleCreationService {
     spawnOptions(request, creationActionId) {
         return {
             name: request.name, temp: request.lifetime === 'temporary',
-            identity: request.name, harness: request.harness,
-            model: request.model, session: request.session, cwd: request.cwd,
-            reasoningEffort: request.reasoningEffort,
-            mission: request.mission, coordinator: request.coordinator,
+            identity: request.name, brain: request.brain, role: request.role, cwd: request.cwd,
+            coordinator: request.coordinator,
             approval: request.permissions.approval, filesystem: request.permissions.filesystem,
-            unattended: request.permissions.unattended, bio: request.bio, persona: request.persona,
+            unattended: request.permissions.unattended,
             monitorConfig: request.monitor,
             configPath: this.options.configPath,
             surface: creationActionId ? 'web' : undefined, creationActionId,

package/dist/application/role-removal-service.js

@@ -4,6 +4,7 @@ import { loadConfig, ROLE_NAME_RE } from '../config.js';
 import { agentDir, stateRoot } from '../paths.js';
 import { rmRole } from '../ops.js';
 import { FleetError } from './errors.js';
+import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
     options;
     constructor(options) {
@@ -45,8 +46,9 @@ export class RoleRemovalService {
             `Stop and uninstall the exact backend registration for '${requested}'.`,
             `Archive then remove ${lifetime === 'temporary' ? temporaryState : permanentState}.`,
         ];
-        if (role?.sourceFile.includes('/fleet.d/'))
-            effects.push(`Remove spawned configuration ${role.sourceFile}.`);
+        const generatedSource = role && provesGeneratedAgentSource(agentDir(requested), cfg.files[0], role.sourceFile);
+        if (generatedSource)
+            effects.push(`Remove generated Agent configuration ${role.sourceFile}.`);
         else if (role)
             effects.push(`Keep hand-written configuration ${role.sourceFile}; the role can be recreated from it.`);
         else
@@ -76,7 +78,8 @@ export class RoleRemovalService {
         mkdirSync(recoveryPath, { recursive: true, mode: 0o700 });
         if (existsSync(sourceState))
             cpSync(sourceState, join(recoveryPath, 'state'), { recursive: true });
-        if (role?.sourceFile.includes('/fleet.d/') && existsSync(role.sourceFile))
+        if (role && provesGeneratedAgentSource(agentDir(preview.role), cfg.files[0], role.sourceFile)
+            && existsSync(role.sourceFile))
             cpSync(role.sourceFile, join(recoveryPath, basename(role.sourceFile)));
         if (role || preview.lifetime === 'temporary')
             await rmRole(cfg, preview.role, this.options.ops);

package/dist/application/task-room-service.d.ts

@@ -2,6 +2,7 @@ import { type FleetConfig } from '../config.js';
 import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
 import { provisionMembers } from '../rooms-tasks/provision.js';
 import { moveTaskToList } from '../rooms-tasks/task-state.js';
+import { type MemberOverrides } from '../rooms-tasks/member-overrides.js';
 import type { RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState } from '../rooms-tasks/types.js';
 export type TaskRoomActor = {
     kind: 'local_control';
@@ -57,6 +58,7 @@ export interface CreateTaskRequest {
     idempotencyKey?: string;
     origin: TaskOrigin;
     list?: string;
+    members?: MemberOverrides;
 }
 export interface CreateRoomRequest {
     actor: TaskRoomActor;
@@ -65,6 +67,7 @@ export interface CreateRoomRequest {
     goal?: string;
     brief?: string;
     briefFile?: string;
+    members?: MemberOverrides;
 }
 export interface TaskRoomServiceDeps {
     loadConfiguration?(path?: string): FleetConfig;
@@ -84,6 +87,8 @@ export declare class TaskRoomApplicationService {
     startTask(input: {
         actor: TaskRoomActor;
         taskId: string;
+        template?: string;
+        members?: MemberOverrides;
     }): Promise<TaskRecord>;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
@@ -179,7 +184,7 @@ export declare class TaskRoomApplicationService {
         name: string;
         version: number;
         description: string;
-        builtin?: boolean;
+        sourceFile?: string;
         room?: import("../rooms-tasks/types.js").TemplateRoomConfig;
         contract?: string;
         members: import("../rooms-tasks/types.js").TemplateMemberSlot[];
@@ -252,6 +257,7 @@ export declare class TaskRoomApplicationService {
         actor: TaskRoomActor;
         taskId: string;
         template?: string;
+        members?: MemberOverrides;
     }): Promise<{
         task: TaskRecord;
         status: 'ready' | 'already_active';