Merge pull request #42 from enlineawork/fix/inspection-context-preventive-scope

fix: congelar contexto de inspección y corregir preventivos

api-v3/src/database/migrations/1790098200000-f6-2-freeze-inspection-context.ts

@@ -0,0 +1,39 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class F62FreezeInspectionContext1790098200000 implements MigrationInterface {
+  name = 'F62FreezeInspectionContext1790098200000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION prevent_inspection_context_mutation()
+      RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        IF NEW.operational_area_id IS DISTINCT FROM OLD.operational_area_id
+          OR NEW.scope_asset_id IS DISTINCT FROM OLD.scope_asset_id
+          OR NEW.operator_company_id IS DISTINCT FROM OLD.operator_company_id THEN
+          RAISE EXCEPTION USING
+            ERRCODE='23514',
+            MESSAGE='El Área, Yacimiento y Operadora de una Inspección quedan fijos desde su creación';
+        END IF;
+        RETURN NEW;
+      END $$
+    `);
+
+    await queryRunner.query(`
+      DROP TRIGGER IF EXISTS trg_inspection_context_immutable ON inspection_visits
+    `);
+    await queryRunner.query(`
+      CREATE TRIGGER trg_inspection_context_immutable
+      BEFORE UPDATE OF operational_area_id, scope_asset_id, operator_company_id
+      ON inspection_visits
+      FOR EACH ROW EXECUTE FUNCTION prevent_inspection_context_mutation()
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DROP TRIGGER IF EXISTS trg_inspection_context_immutable ON inspection_visits
+    `);
+    await queryRunner.query('DROP FUNCTION IF EXISTS prevent_inspection_context_mutation()');
+  }
+}

api-v3/src/inspection-visits/dto/update-inspection-visit.dto.ts

@@ -1,9 +1,9 @@
 import { Transform } from 'class-transformer';
 import {
+  IsEmpty,
   IsISO8601,
   IsOptional,
   IsString,
-  IsUUID,
   MaxLength,
 } from 'class-validator';
 
@@ -17,15 +17,15 @@ export class UpdateInspectionVisitDto {
   objective?: string | null;
 
   @IsOptional()
-  @IsUUID('4')
+  @IsEmpty({ message: 'El Yacimiento se fija al crear la Inspección y no puede modificarse' })
   scopeAssetId?: string | null;
 
   @IsOptional()
-  @IsUUID('4')
+  @IsEmpty({ message: 'El Área se fija al crear la Inspección y no puede modificarse' })
   operationalAreaId?: string | null;
 
   @IsOptional()
-  @IsUUID('4')
+  @IsEmpty({ message: 'La Operadora se fija al crear la Inspección y no puede modificarse' })
   operatorCompanyId?: string | null;
 
   @IsOptional()

api-v3/src/inspection-visits/inspection-preventive-candidates.controller.ts

@@ -0,0 +1,17 @@
+import { Controller, Get, Param, ParseUUIDPipe, Query } from '@nestjs/common';
+import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
+import { InspectionPreventiveCandidatesService } from './inspection-preventive-candidates.service';
+
+@Controller('inspection-visits')
+export class InspectionPreventiveCandidatesController {
+  constructor(private readonly candidates: InspectionPreventiveCandidatesService) {}
+
+  @Get(':id/preventive-candidates')
+  @RequirePermissions('inspections.read')
+  list(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Query('search') search?: string,
+  ) {
+    return this.candidates.list(id, search);
+  }
+}

api-v3/src/inspection-visits/inspection-preventive-candidates.service.ts

@@ -0,0 +1,77 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+export interface InspectionPreventiveCandidate {
+  id: string;
+  code: string;
+  name: string;
+  typeName: string;
+}
+
+@Injectable()
+export class InspectionPreventiveCandidatesService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async list(visitId: string, search?: string): Promise<{ data: InspectionPreventiveCandidate[] }> {
+    const [context] = (await this.dataSource.query(`
+      SELECT
+        visit.operational_area_id AS "operationalAreaId",
+        COALESCE(visit.scope_asset_id, visit.operational_area_id) AS "scopeAssetId"
+      FROM inspection_visits visit
+      WHERE visit.id = $1::uuid
+    `, [visitId])) as Array<{
+      operationalAreaId: string | null;
+      scopeAssetId: string | null;
+    }>;
+
+    if (!context) {
+      throw new NotFoundException({
+        code: 'INSPECTION_VISIT_NOT_FOUND',
+        message: 'Visita de inspección no encontrada',
+      });
+    }
+
+    if (!context.operationalAreaId || !context.scopeAssetId) return { data: [] };
+
+    const term = search?.trim().slice(0, 200) ?? '';
+    const rows = (await this.dataSource.query(`
+      WITH RECURSIVE scope_tree AS (
+        SELECT root.id
+        FROM assets root
+        WHERE root.id = $2::uuid
+        UNION ALL
+        SELECT child.id
+        FROM assets child
+        INNER JOIN scope_tree parent_scope ON parent_scope.id = child.parent_id
+      )
+      SELECT
+        asset.id,
+        asset.code,
+        asset.name,
+        asset_type.name AS "typeName"
+      FROM scope_tree
+      INNER JOIN assets asset ON asset.id = scope_tree.id
+      INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
+      WHERE asset.id <> $2::uuid
+        AND asset.operational_area_id = $3::uuid
+        AND asset.information_status <> 'INACTIVE'
+        AND lower(asset_type.code) IN ('instalacion', 'subinstalacion')
+        AND NOT EXISTS (
+          SELECT 1
+          FROM inspection_visit_assets linked
+          WHERE linked.visit_id = $1::uuid
+            AND linked.asset_id = asset.id
+        )
+        AND (
+          $4::text = ''
+          OR asset.code ILIKE '%' || $4::text || '%'
+          OR asset.name ILIKE '%' || $4::text || '%'
+          OR COALESCE(asset.common_name, '') ILIKE '%' || $4::text || '%'
+        )
+      ORDER BY asset_type.name, asset.name, asset.code
+      LIMIT 100
+    `, [visitId, context.scopeAssetId, context.operationalAreaId, term])) as InspectionPreventiveCandidate[];
+
+    return { data: rows };
+  }
+}

api-v3/src/inspection-visits/inspection-visits.module.ts

@@ -10,17 +10,25 @@ import { FieldInventoryController } from './field-inventory.controller';
 import { FieldInventoryService } from './field-inventory.service';
 import { InspectionPlanningCreateService } from './inspection-planning-create.service';
 import { InspectionPlanningHierarchyService } from './inspection-planning-hierarchy.service';
+import { InspectionPreventiveCandidatesController } from './inspection-preventive-candidates.controller';
+import { InspectionPreventiveCandidatesService } from './inspection-preventive-candidates.service';
 import { InspectionVisitLifecycleService } from './inspection-visit-lifecycle.service';
 import { InspectionVisitsController } from './inspection-visits.controller';
 import { InspectionVisitsService } from './inspection-visits.service';
 
 @Module({
   imports: [AuditModule, AssetMasterModule, InspectionFindingsModule],
-  controllers: [InspectionVisitsController, FieldInventoryController, FieldFindingsController],
+  controllers: [
+    InspectionVisitsController,
+    InspectionPreventiveCandidatesController,
+    FieldInventoryController,
+    FieldFindingsController,
+  ],
   providers: [
     { provide: InspectionVisitsService, useClass: F4InspectionVisitsService },
     InspectionPlanningCreateService,
     InspectionPlanningHierarchyService,
+    InspectionPreventiveCandidatesService,
     InspectionVisitLifecycleService,
     FieldInventoryService,
     F3FieldInventoryStructureService,

api-v3/test/unit/f6-1-inspection-yacimiento-scope-review.test.ts

@@ -62,11 +62,17 @@ test('F6.1 operator choices are resolved at the planned timestamp', () => {
   assert.match(createPage, /\[areaId, plannedStartAt\]/);
 });
 
-test('F6.1 WEB keeps Area and Yacimiento as separate concepts when editing', () => {
+test('F6.1 WEB keeps Area and Yacimiento as separate concepts and freezes context after creation', () => {
   const source = web('src/pages/InspectionVisitEditorF4Page.tsx');
 
   assert.doesNotMatch(source, /<span>Área \/ Yacimiento<\/span>/);
   assert.match(source, /<span>Área<\/span>/);
   assert.match(source, /<span>Yacimiento<\/span>/);
-  assert.match(source, /scopeAssetId: visit\?\.scopeAsset\?\.id \?\? null/);
+  assert.match(source, /<span>Operadora<\/span>/);
+  assert.match(source, /visit\.operationalArea\.name[\s\S]{0,160}readOnly/);
+  assert.match(source, /visit\.scopeAsset\.name[\s\S]{0,160}readOnly/);
+  assert.match(source, /visit\.operatorCompany\.name[\s\S]{0,160}readOnly/);
+  assert.doesNotMatch(source, /updateInspectionVisit\(id, \{[\s\S]{0,300}scopeAssetId:/);
+  assert.doesNotMatch(source, /updateInspectionVisit\(id, \{[\s\S]{0,300}operationalAreaId:/);
+  assert.doesNotMatch(source, /updateInspectionVisit\(id, \{[\s\S]{0,300}operatorCompanyId:/);
 });

api-v3/test/unit/f6-1-operational-context-consistency.test.ts

@@ -75,12 +75,20 @@ test('F6.1 historical operational lists read Company and Area from the parent In
   assert.doesNotMatch(reports, /context_asset\.operator_company_id/);
 });
 
-test('F6.1 WEB Inventory searches use physical Area and never the operator snapshot filter', () => {
+test('F6.1 WEB Inventory searches use physical scope and never the operator snapshot filter', () => {
   const inspectionEditor = source('../web-v2/src/pages/InspectionVisitEditorF4Page.tsx');
+  const preventiveApi = source('../web-v2/src/features/inspections/preventiveCandidatesApi.ts');
+  const preventiveService = source('src/inspection-visits/inspection-preventive-candidates.service.ts');
   const fieldDiscoveries = source('../web-v2/src/pages/FieldDiscoveriesPage.tsx');
   const inventoryMerge = source('../web-v2/src/lib/inventoryMergeApi.ts');
 
-  for (const page of [inspectionEditor, fieldDiscoveries, inventoryMerge]) {
+  assert.match(inspectionEditor, /listInspectionPreventiveCandidates\(id, assetSearch\)/);
+  assert.match(preventiveApi, /inspection-visits\/\$\{visitId\}\/preventive-candidates/);
+  assert.match(preventiveService, /COALESCE\(visit\.scope_asset_id, visit\.operational_area_id\) AS "scopeAssetId"/);
+  assert.doesNotMatch(preventiveService, /asset\.operator_company_id/);
+  assert.doesNotMatch(inspectionEditor, /listAssets\(\{[\s\S]{0,300}operatorCompanyId:/);
+
+  for (const page of [fieldDiscoveries, inventoryMerge]) {
     assert.match(page, /listAssets\(\{[\s\S]{0,300}operationalAreaId:/);
     assert.doesNotMatch(page, /listAssets\(\{[\s\S]{0,300}operatorCompanyId:/);
   }

api-v3/test/unit/f6-2-inspection-context-preventive.test.ts

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import test from 'node:test';
+
+const api = (path: string) => readFileSync(resolve(process.cwd(), path), 'utf8');
+const web = (path: string) => readFileSync(resolve(process.cwd(), '..', 'web-v2', path), 'utf8');
+
+test('F6.2 protects the frozen Inspection context at database level', () => {
+  const migration = api('src/database/migrations/1790098200000-f6-2-freeze-inspection-context.ts');
+
+  assert.match(migration, /prevent_inspection_context_mutation/);
+  assert.match(migration, /NEW\.operational_area_id IS DISTINCT FROM OLD\.operational_area_id/);
+  assert.match(migration, /NEW\.scope_asset_id IS DISTINCT FROM OLD\.scope_asset_id/);
+  assert.match(migration, /NEW\.operator_company_id IS DISTINCT FROM OLD\.operator_company_id/);
+  assert.match(migration, /BEFORE UPDATE OF operational_area_id, scope_asset_id, operator_company_id/);
+});
+
+test('F6.2 preventive candidates are descendants of the frozen Yacimiento only', () => {
+  const service = api('src/inspection-visits/inspection-preventive-candidates.service.ts');
+  const controller = api('src/inspection-visits/inspection-preventive-candidates.controller.ts');
+
+  assert.match(service, /COALESCE\(visit\.scope_asset_id, visit\.operational_area_id\) AS "scopeAssetId"/);
+  assert.match(service, /WITH RECURSIVE scope_tree AS/);
+  assert.match(service, /child\.parent_id/);
+  assert.match(service, /asset\.operational_area_id = \$3::uuid/);
+  assert.match(service, /lower\(asset_type\.code\) IN \('instalacion', 'subinstalacion'\)/);
+  assert.match(service, /NOT EXISTS \([\s\S]*inspection_visit_assets linked/);
+  assert.match(controller, /:id\/preventive-candidates/);
+});
+
+test('F6.2 WEB uses the server-scoped preventive selector instead of the mutable Area form', () => {
+  const page = web('src/pages/InspectionVisitEditorF4Page.tsx');
+  const apiClient = web('src/features/inspections/preventiveCandidatesApi.ts');
+
+  assert.match(page, /listInspectionPreventiveCandidates\(id, assetSearch\)/);
+  assert.doesNotMatch(page, /listAssets\(\{[\s\S]{0,220}operationalAreaId: form\.operationalAreaId/);
+  assert.match(page, /Sólo se muestran Instalaciones y Subinstalaciones pertenecientes al Yacimiento/);
+  assert.match(apiClient, /inspection-visits\/\$\{visitId\}\/preventive-candidates/);
+});

api-v3/test/unit/inspection-visits-dto.test.ts

@@ -7,6 +7,7 @@ import { ChangeInspectionVisitStatusDto } from '../../src/inspection-visits/dto/
 import { CreateInspectionVisitDto } from '../../src/inspection-visits/dto/create-inspection-visit.dto';
 import { ReplaceInspectionVisitAssetsDto } from '../../src/inspection-visits/dto/replace-inspection-visit-assets.dto';
 import { ReplaceInspectionVisitTeamDto } from '../../src/inspection-visits/dto/replace-inspection-visit-team.dto';
+import { UpdateInspectionVisitDto } from '../../src/inspection-visits/dto/update-inspection-visit.dto';
 
 const AREA_ID = '16e54e65-60cf-4739-b0d1-ccdd904fbfd5';
 const COMPANY_ID = 'ce96211d-ac15-4421-8868-4185323aff61';
@@ -25,6 +26,25 @@ test('visit DTO accepts only the minimum planning data required for quick creati
   assert.equal(dto.leadInspectorUserId, USER_ID);
 });
 
+test('visit update DTO keeps Area, Yacimiento and Operadora immutable after creation', async () => {
+  const contextAttempt = plainToInstance(UpdateInspectionVisitDto, {
+    operationalAreaId: AREA_ID,
+    scopeAssetId: AREA_ID,
+    operatorCompanyId: COMPANY_ID,
+  });
+  const errors = await validate(contextAttempt);
+  assert.equal(errors.some((error) => error.property === 'operationalAreaId'), true);
+  assert.equal(errors.some((error) => error.property === 'scopeAssetId'), true);
+  assert.equal(errors.some((error) => error.property === 'operatorCompanyId'), true);
+
+  const ordinaryUpdate = plainToInstance(UpdateInspectionVisitDto, {
+    objective: 'Control preventivo programado',
+    plannedStartAt: '2026-09-17T12:00:00.000Z',
+    instructions: 'Coordinar ingreso con la Operadora.',
+  });
+  assert.deepEqual(await validate(ordinaryUpdate), []);
+});
+
 test('asset and team DTOs reject duplicate references', async () => {
   const assets = Object.assign(new ReplaceInspectionVisitAssetsDto(), {
     assetIds: [AREA_ID, AREA_ID],

web-v2/src/features/inspections/preventiveCandidatesApi.ts

@@ -0,0 +1,43 @@
+export interface InspectionPreventiveCandidate {
+  id: string;
+  code: string;
+  name: string;
+  typeName: string;
+}
+
+interface PreventiveCandidateResponse {
+  data: InspectionPreventiveCandidate[];
+}
+
+export async function listInspectionPreventiveCandidates(
+  visitId: string,
+  search = '',
+): Promise<InspectionPreventiveCandidate[]> {
+  const query = new URLSearchParams();
+  const term = search.trim();
+  if (term) query.set('search', term);
+
+  const response = await fetch(
+    `/api/v3/inspection-visits/${visitId}/preventive-candidates${query.size ? `?${query}` : ''}`,
+    {
+      method: 'GET',
+      credentials: 'same-origin',
+      headers: { Accept: 'application/json' },
+    },
+  );
+
+  if (!response.ok) {
+    let message = 'No se pudo cargar el Inventario disponible para esta Inspección';
+    try {
+      const payload = await response.json() as { message?: string | string[] };
+      if (Array.isArray(payload.message)) message = payload.message.join('. ');
+      else if (payload.message) message = payload.message;
+    } catch {
+      // Conserva el mensaje funcional cuando la respuesta no sea JSON.
+    }
+    throw new Error(message);
+  }
+
+  const payload = await response.json() as PreventiveCandidateResponse;
+  return payload.data ?? [];
+}

web-v2/src/pages/InspectionVisitEditorF4Page.tsx

@@ -11,13 +11,18 @@ import {
   inspectionStatusClass,
   inspectionVisitStatusLabel,
 } from '../features/inspections/inspectionPresentation';
+import {
+  listInspectionPreventiveCandidates,
+} from '../features/inspections/preventiveCandidatesApi';
+import type {
+  InspectionPreventiveCandidate,
+} from '../features/inspections/preventiveCandidatesApi';
 import {
   createInspectionVisit,
   excludeInspectionVisitAsset,
   generateInspectionVisitChecklist,
   getInspectionVisit,
   includeInspectionVisitAsset,
-  listAssets,
   listInspectionAssignees,
   listInspectionPlanningAreas,
   listInspectionPlanningOperators,
@@ -26,7 +31,6 @@ import {
   updateInspectionVisit,
 } from '../lib/api';
 import type {
-  AssetListItem,
   InspectionPerson,
   InspectionPlanningContextAsset,
   InspectionVisit,
@@ -100,7 +104,7 @@ export function InspectionVisitEditorF4Page() {
   const [areas, setAreas] = useState<InspectionPlanningContextAsset[]>([]);
   const [operators, setOperators] = useState<InspectionPlanningContextAsset[]>([]);
   const [assignees, setAssignees] = useState<InspectionPerson[]>([]);
-  const [assets, setAssets] = useState<AssetListItem[]>([]);
+  const [assets, setAssets] = useState<InspectionPreventiveCandidate[]>([]);
   const [assetSearch, setAssetSearch] = useState('');
   const [newAssetId, setNewAssetId] = useState('');
   const [leadInspectorId, setLeadInspectorId] = useState('');
@@ -136,9 +140,9 @@ export function InspectionVisitEditorF4Page() {
   };
 
   useEffect(() => {
-    listInspectionPlanningAreas().then(setAreas).catch(() => undefined);
+    if (isNew) listInspectionPlanningAreas().then(setAreas).catch(() => undefined);
     if (canAssign) listInspectionAssignees().then(setAssignees).catch(() => undefined);
-  }, [canAssign]);
+  }, [canAssign, isNew]);
 
   useEffect(() => {
     if (!isNew || form.operationalAreaId || !context.areaId) return;
@@ -158,29 +162,27 @@ export function InspectionVisitEditorF4Page() {
   }, [id]);
 
   useEffect(() => {
-    if (!form.operationalAreaId) {
+    if (!isNew || !form.operationalAreaId) {
       setOperators([]);
       return;
     }
     listInspectionPlanningOperators(form.operationalAreaId)
       .then(setOperators)
       .catch(() => setOperators([]));
-  }, [form.operationalAreaId]);
+  }, [form.operationalAreaId, isNew]);
 
   useEffect(() => {
-    if (!form.operationalAreaId || !form.operatorCompanyId) {
+    if (!id || !visit) {
       setAssets([]);
       return;
     }
     const timer = window.setTimeout(() => {
-      listAssets({
+      listInspectionPreventiveCandidates(id, assetSearch)
-        pageSize: 100,
+        .then(setAssets)
-        search: assetSearch.trim(),
+        .catch((requestError) => setError(errorMessage(requestError)));
-        operationalAreaId: form.operationalAreaId,
-      }).then((response) => setAssets(response.data)).catch(() => undefined);
     }, 220);
     return () => window.clearTimeout(timer);
-  }, [assetSearch, form.operationalAreaId, form.operatorCompanyId]);
+  }, [id, assetSearch, visit?.updatedAt]);
 
   const planningEditable = !visit || visit.status === 'DRAFT' || visit.status === 'PLANNED';
   const activeAssetIds = useMemo(() => new Set(visit?.assets.map((asset) => asset.id) ?? []), [visit]);
@@ -209,13 +211,10 @@ export function InspectionVisitEditorF4Page() {
       } else if (id) {
         applyVisit(await updateInspectionVisit(id, {
           objective: form.objective.trim() || null,
-          scopeAssetId: visit?.scopeAsset?.id ?? null,
-          operationalAreaId: form.operationalAreaId || null,
-          operatorCompanyId: form.operatorCompanyId || null,
           plannedStartAt,
           instructions: form.instructions.trim() || null,
         }));
-        setSuccess('Planificación actualizada. Regenerá el checklist si cambió contexto o fecha.');
+        setSuccess('Planificación actualizada. Si cambió la fecha, regenerá el checklist.');
       }
     } catch (requestError) {
       setError(errorMessage(requestError));
@@ -240,6 +239,7 @@ export function InspectionVisitEditorF4Page() {
     setBusy(true); setError(''); setSuccess('');
     try {
       applyVisit(await replaceInspectionVisitAssets(id, [...activeAssetIds, newAssetId]), false);
+      setAssets((current) => current.filter((asset) => asset.id !== newAssetId));
       setNewAssetId('');
       setSuccess('Registro agregado como preventivo.');
     } catch (requestError) { setError(errorMessage(requestError)); }
@@ -340,12 +340,12 @@ export function InspectionVisitEditorF4Page() {
     {error && <Alert>{error}</Alert>}{success && <Alert type="success">{success}</Alert>}
 
     <form className={`panel form-panel ${isNew ? 'inspection-quick-create' : ''}`} onSubmit={saveGeneral}>
-      <div className="panel-heading"><div><span className="eyebrow">{isNew ? 'CREACIÓN RÁPIDA' : 'PLANIFICACIÓN'}</span><h2>Contexto y fecha de inicio</h2><p className="section-copy">No existe título independiente ni fecha de fin planificada. El cierre real se registra al terminar el trabajo de campo.</p></div>{visit && <small className="muted">Actualizado {formatDate(visit.updatedAt)}</small>}</div>
+      <div className="panel-heading"><div><span className="eyebrow">{isNew ? 'CREACIÓN RÁPIDA' : 'PLANIFICACIÓN'}</span><h2>Contexto y fecha de inicio</h2><p className="section-copy">El Área, Yacimiento y Operadora quedan fijados al crear la Inspección. La fecha puede reprogramarse antes del trabajo de campo.</p></div>{visit && <small className="muted">Actualizado {formatDate(visit.updatedAt)}</small>}</div>
       {visit && <div className="inspection-generated-code"><small>Identificador institucional</small><strong>{visit.code}</strong></div>}
       <div className="form-grid">
-        <label className="field"><span>Área</span><SearchableSelect searchPlaceholder="Buscar Área…" value={form.operationalAreaId} onChange={(event) => { context.setAreaId(event.target.value); setForm((current) => ({ ...current, operationalAreaId: event.target.value, operatorCompanyId: '' })); }} required disabled={!canManage || !planningEditable}><option value="">Seleccionar Área…</option>{areas.map((area) => <option key={area.id} value={area.id}>{area.name} · {area.code}</option>)}</SearchableSelect></label>
+        {isNew ? <label className="field"><span>Área</span><SearchableSelect searchPlaceholder="Buscar Área…" value={form.operationalAreaId} onChange={(event) => { context.setAreaId(event.target.value); setForm((current) => ({ ...current, operationalAreaId: event.target.value, operatorCompanyId: '' })); }} required disabled={!canManage || !planningEditable}><option value="">Seleccionar Área…</option>{areas.map((area) => <option key={area.id} value={area.id}>{area.name} · {area.code}</option>)}</SearchableSelect></label> : <label className="field"><span>Área</span><input value={visit?.operationalArea ? `${visit.operationalArea.name} · ${visit.operationalArea.code}` : 'Sin Área'} readOnly aria-readonly="true" /></label>}
-        {!isNew && <label className="field"><span>Yacimiento</span><input value={visit?.scopeAsset?.name ?? 'Sin Yacimiento'} readOnly aria-readonly="true" /></label>}
+        {!isNew && <label className="field"><span>Yacimiento</span><input value={visit?.scopeAsset ? `${visit.scopeAsset.name} · ${visit.scopeAsset.code}` : 'Sin Yacimiento'} readOnly aria-readonly="true" /></label>}
-        <label className="field"><span>Operadora</span><SearchableSelect searchPlaceholder="Buscar Operadora…" value={form.operatorCompanyId} onChange={(event) => { context.setCompanyId(event.target.value); setForm((current) => ({ ...current, operatorCompanyId: event.target.value })); }} required disabled={!canManage || !planningEditable || !form.operationalAreaId}><option value="">Seleccionar Operadora…</option>{operators.map((operator) => <option key={operator.id} value={operator.id}>{operator.name} · {operator.code}</option>)}</SearchableSelect></label>
+        {isNew ? <label className="field"><span>Operadora</span><SearchableSelect searchPlaceholder="Buscar Operadora…" value={form.operatorCompanyId} onChange={(event) => { context.setCompanyId(event.target.value); setForm((current) => ({ ...current, operatorCompanyId: event.target.value })); }} required disabled={!canManage || !planningEditable || !form.operationalAreaId}><option value="">Seleccionar Operadora…</option>{operators.map((operator) => <option key={operator.id} value={operator.id}>{operator.name} · {operator.code}</option>)}</SearchableSelect></label> : <label className="field"><span>Operadora</span><input value={visit?.operatorCompany ? `${visit.operatorCompany.name} · ${visit.operatorCompany.code}` : 'Sin Operadora'} readOnly aria-readonly="true" /></label>}
         <label className="field"><span>Fecha y hora de inicio</span><input type="datetime-local" value={form.plannedStartAt} onChange={(event) => setForm((current) => ({ ...current, plannedStartAt: event.target.value }))} required disabled={!canManage || !planningEditable} /></label>
         {isNew && <label className="field"><span>Inspector responsable</span><SearchableSelect searchPlaceholder="Buscar Inspector…" value={leadInspectorId} onChange={(event) => setLeadInspectorId(event.target.value)} required disabled={!canAssign}><option value="">Seleccionar Inspector…</option>{assignees.map((person) => <option key={person.id} value={person.id}>{personName(person)} · {person.username}</option>)}</SearchableSelect></label>}
       </div>
@@ -354,15 +354,15 @@ export function InspectionVisitEditorF4Page() {
     </form>
 
     {visit && <article className="panel inspection-checklist-panel">
-      <div className="panel-heading"><div><span className="eyebrow">CHECKLIST TÉCNICO</span><h2>Antecedentes y controles</h2><p className="section-copy">Se construye por Área, Operadora y fecha. Las respuestas administrativas de empresa no modifican este checklist.</p></div>{canManage && planningEditable && <button type="button" className="button secondary" onClick={() => void regenerateChecklist()} disabled={busy}>Regenerar checklist</button>}</div>
+      <div className="panel-heading"><div><span className="eyebrow">CHECKLIST TÉCNICO</span><h2>Antecedentes y controles</h2><p className="section-copy">Se construye para el Área, Yacimiento y Operadora fijados en la Inspección, tomando la fecha planificada. Las respuestas administrativas de empresa no modifican este checklist.</p></div>{canManage && planningEditable && <button type="button" className="button secondary" onClick={() => void regenerateChecklist()} disabled={busy}>Regenerar checklist</button>}</div>
-      {visit.checklist.stale && <Alert>El contexto o la fecha cambió. Regenerá el checklist antes de planificar.</Alert>}
+      {visit.checklist.stale && <Alert>La fecha cambió. Regenerá el checklist antes de planificar.</Alert>}
       <div className="inspection-checklist-metrics"><div><strong>{visit.checklist.verificationOverdue}</strong><span>controles vencidos</span></div><div><strong>{visit.checklist.upcomingControls}</strong><span>próximos 30 días</span></div><div><strong>{visit.checklist.antecedents}</strong><span>antecedentes</span></div><div><strong>{visit.checklist.actionableAssets}</strong><span>registros sugeridos</span></div></div>
       {visit.checklist.items.length === 0 ? <EmptyState title="Sin antecedentes" text="No hay Hallazgos históricos técnicos para este contexto." /> : <div className="table-scroll"><table><thead><tr><th>Tipo</th><th>Hallazgo</th><th>Inventario</th><th>Fecha</th><th>Gravedad</th></tr></thead><tbody>{visit.checklist.items.map((item) => <tr key={item.id}><td><span className={`status-badge ${item.itemKind === 'ANTECEDENT' ? '' : 'warning'}`}>{checklistLabel(item.itemKind)}</span></td><td><Link className="history-asset-link" to={`/hallazgos/${item.findingId}`}><strong>{item.findingTitle}</strong><small>{item.findingCode}</small></Link></td><td><Link className="history-asset-link" to={`/inventarios/${item.asset.id}`}><strong>{item.asset.name}</strong><small>{item.asset.code} · {item.asset.typeName}</small></Link></td><td>{formatDateOnly(item.referenceOn)}</td><td>{item.severity ?? '—'}</td></tr>)}</tbody></table></div>}
     </article>}
 
     {visit && visit.verificationFindings.length > 0 && <article className="panel verification-visit-findings"><div className="panel-heading"><div><span className="eyebrow">VERIFICACIÓN</span><h2>Hallazgos a controlar</h2></div><span className="count-pill">{visit.verificationFindings.length}</span></div><div className="dossier-link-list">{visit.verificationFindings.map((finding) => <Link key={finding.id} to={`/hallazgos/${finding.id}`}><div><strong>{finding.title}</strong><small>{finding.code} · {finding.assetName} · objetivo {formatDateOnly(finding.targetControlOn ?? finding.nextControlOn)}</small>{finding.resultNotes && <small>{finding.resultNotes}</small>}</div><span>{finding.outcome === 'RESOLVED' ? 'Solucionado' : finding.outcome === 'NOT_RESOLVED' ? 'No solucionado' : finding.outcome === 'REQUIRES_NEW_DATE' ? 'Reprogramar' : 'Pendiente'}</span><Icon name="chevron" size={16} /></Link>)}</div></article>}
 
-    {visit && planningEditable && canManage && <form className="panel survey-add-target" onSubmit={addPreventiveAsset}><div className="panel-heading"><div><span className="eyebrow">PREVENTIVO</span><h2>Agregar Inventario sin pendiente previo</h2></div></div><label className="field"><span>Buscar Inventario</span><input value={assetSearch} onChange={(event) => setAssetSearch(event.target.value)} placeholder="Código o nombre" /></label><label className="field"><span>Inventario</span><SearchableSelect value={newAssetId} onChange={(event) => setNewAssetId(event.target.value)} required><option value="">Seleccionar…</option>{candidateAssets.map((asset) => <option key={asset.id} value={asset.id}>{asset.code} · {asset.name} · {asset.type.name}</option>)}</SearchableSelect></label><div className="form-actions"><button className="button primary" disabled={busy || !newAssetId}><Icon name="plus" />Agregar preventivo</button></div></form>}
+    {visit && planningEditable && canManage && <form className="panel survey-add-target" onSubmit={addPreventiveAsset}><div className="panel-heading"><div><span className="eyebrow">PREVENTIVO</span><h2>Agregar Inventario sin pendiente previo</h2><p className="section-copy">Sólo se muestran Instalaciones y Subinstalaciones pertenecientes al Yacimiento fijado para esta Inspección.</p></div></div><label className="field"><span>Buscar Inventario</span><input value={assetSearch} onChange={(event) => setAssetSearch(event.target.value)} placeholder="Código o nombre" /></label><label className="field"><span>Inventario</span><SearchableSelect value={newAssetId} onChange={(event) => setNewAssetId(event.target.value)} required><option value="">Seleccionar…</option>{candidateAssets.map((asset) => <option key={asset.id} value={asset.id}>{asset.code} · {asset.name} · {asset.typeName}</option>)}</SearchableSelect></label><div className="form-actions"><button className="button primary" disabled={busy || !newAssetId}><Icon name="plus" />Agregar preventivo</button></div></form>}
 
     {visit && <article className="table-panel inspection-assets"><div className="table-summary"><strong>{visit.assets.length} incluidos</strong><span>{visit.checklist.excludedAssets} excluidos con trazabilidad</span></div>{visit.planningAssets.length === 0 ? <EmptyState title="Sin Inventarios" text="Generá el checklist o agregá un preventivo." /> : <div className="table-scroll"><table><thead><tr><th>Inventario</th><th>Origen</th><th>Estado</th><th>Motivo</th><th /></tr></thead><tbody>{visit.planningAssets.map((asset) => <tr key={asset.id}><td><Link className="history-asset-link" to={`/inventarios/${asset.id}`}><strong>{asset.name}</strong><small>{asset.code} · {asset.typeName}</small></Link></td><td>{sourceLabel(asset.planningSource)}</td><td>{asset.included ? 'Incluido' : 'Excluido'}</td><td>{asset.exclusionReason ?? '—'}</td><td>{canManage && planningEditable && (asset.included ? <button type="button" className="button danger-outline compact" onClick={() => void excludeAsset(asset.id)}>Excluir</button> : <button type="button" className="button secondary compact" onClick={() => void reincludeAsset(asset.id)}>Reincorporar</button>)}</td></tr>)}</tbody></table></div>}</article>}