F6.1 hotfix · jerarquía de Inspecciones y scope Yacimiento (#37)

Corrige creación de Inspección, separa Departamento→Área→Yacimiento, elimina el UPDATE oculto de checklist en lectura, integra Preparación para campo como etapa de Inspección, limita operaciones Android al Yacimiento, preserva scope en edición, auto-incluye Inventarios accionables, valida Operadora a plannedStartAt y recompila Android 0.15.2/vc24 con el ícono exacto de presentación.
2026-09-10 16:06:48 -03:00
parent ce2a85a26a
commit 7be5d89204
29 changed files with 1330 additions and 218 deletions
@@ -1,9 +1,18 @@
-import { IsISO8601, IsUUID } from 'class-validator';
+import { IsISO8601, IsOptional, IsUUID } from 'class-validator';

 export class CreateInspectionVisitDto {
  @IsUUID('4')
  operationalAreaId!: string;

+  /**
+   * Yacimiento concreto de la Inspección. Se mantiene opcional sólo para no
+   * romper clientes Android anteriores, que todavía abren una Inspección a
+   * nivel Área; la WEB F6.1 siempre lo envía.
+   */
+  @IsOptional()
+  @IsUUID('4')
+  scopeAssetId?: string;
+
  @IsUUID('4')
  operatorCompanyId!: string;

@@ -4,15 +4,25 @@ import { AuditService } from '../audit/audit.service';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
 import type { CreateInspectionVisitDto } from './dto/create-inspection-visit.dto';
 import type { ListInspectionVisitsQueryDto } from './dto/list-inspection-visits-query.dto';
-import type { InspectionVisitView } from './inspection-visits.service';
+import type {
+  InspectionChecklistItemKind,
+  InspectionVisitView,
+} from './inspection-visits.service';
 import { InspectionVisitsService } from './inspection-visits.service';

+type F4ChecklistClassification = {
+  findingId: string;
+  itemKind: InspectionChecklistItemKind;
+  referenceOn: string | null;
+};
+
 /**
 * Capa activa F4 sobre el servicio de Inspecciones.
 *
- * Conserva las operaciones de planificación/equipo/Inventario ya probadas y aplica
- * la clasificación técnica F4 del checklist. El contrato público de Inspección ya
- * no expone título independiente ni fecha prevista de fin.
+ * El checklist persistido es una generación histórica append-only. F4 necesita
+ * mostrar la clasificación vigente de controles, pero una lectura nunca debe
+ * reescribir esa generación. La clasificación se deriva con SELECT y se aplica
+ * sólo a la vista devuelta por la API.
 */
@Injectable()
 export class F4InspectionVisitsService extends InspectionVisitsService {
@@ -32,8 +42,8 @@ export class F4InspectionVisitsService extends InspectionVisitsService {
  }

  override async getById(id: string): Promise<InspectionVisitView> {
-    await this.reclassifyCurrentChecklist(id);
-    return this.normalizeChecklist(await super.getById(id));
+    const visit = await super.getById(id);
+    return this.normalizeChecklist(await this.classifyChecklistView(visit));
  }

  override async create(
@@ -41,9 +51,8 @@ export class F4InspectionVisitsService extends InspectionVisitsService {
    principal: AuthPrincipal,
    request: RequestWithContext,
  ): Promise<InspectionVisitView> {
-    const created = await super.create(dto, principal, request);
-    await this.reclassifyCurrentChecklist(created.id);
-    return this.normalizeChecklist(await super.getById(created.id));
+    const visit = await super.create(dto, principal, request);
+    return this.normalizeChecklist(await this.classifyChecklistView(visit));
  }

  override async generateChecklist(
@@ -51,88 +60,106 @@ export class F4InspectionVisitsService extends InspectionVisitsService {
    principal: AuthPrincipal,
    request: RequestWithContext,
  ): Promise<InspectionVisitView> {
-    await super.generateChecklist(id, principal, request);
-    await this.reclassifyCurrentChecklist(id);
-    return this.normalizeChecklist(await super.getById(id));
+    const visit = await super.generateChecklist(id, principal, request);
+    return this.normalizeChecklist(await this.classifyChecklistView(visit));
  }

  private normalizeChecklist<T>(visit: T): T {
    if (!visit || typeof visit !== 'object' || !('checklist' in visit)) return visit;
    const view = visit as T & InspectionVisitView;
+    const items = view.checklist.items.filter((item) => item.itemKind !== 'COMPANY_OVERDUE');
+    const actionableAssetIds = new Set(
+      items
+        .filter((item) => ['VERIFICATION_OVERDUE', 'UPCOMING_CONTROL'].includes(item.itemKind))
+        .map((item) => item.asset.id),
+    );
    view.checklist = {
      ...view.checklist,
+      antecedents: items.filter((item) => item.itemKind === 'ANTECEDENT').length,
      companyOverdue: 0,
-      items: view.checklist.items.filter((item) => item.itemKind !== 'COMPANY_OVERDUE'),
+      verificationOverdue: items.filter((item) => item.itemKind === 'VERIFICATION_OVERDUE').length,
+      upcomingControls: items.filter((item) => item.itemKind === 'UPCOMING_CONTROL').length,
+      actionableAssets: actionableAssetIds.size,
+      items,
    };
    return view;
  }

-  private async reclassifyCurrentChecklist(visitId: string): Promise<void> {
-    await this.f4DataSource.transaction(async (manager) => {
-      const [visit] = await manager.query(`
-        SELECT checklist_generation AS generation, planned_start_at AS "plannedStartAt"
-        FROM inspection_visits
-        WHERE id=$1
-        FOR UPDATE
-      `, [visitId]) as Array<{ generation: number; plannedStartAt: Date | null }>;
-      if (!visit || Number(visit.generation) < 1 || !visit.plannedStartAt) return;
+  /**
+   * Deriva el estado F4 actual de los ítems sin mutar la generación persistida.
+   * La fuente administrativa de empresa vive a nivel Acta; en este checklist de
+   * campo sólo importan próximos controles y verificaciones no resueltas.
+   */
+  private async classifyChecklistView(visit: InspectionVisitView): Promise<InspectionVisitView> {
+    if (!visit.plannedStartAt || visit.checklist.items.length === 0) return visit;
+    const findingIds = [...new Set(visit.checklist.items.map((item) => item.findingId))];
+    if (findingIds.length === 0) return visit;
+    const targetDate = new Date(visit.plannedStartAt).toISOString().slice(0, 10);

-      const targetDate = new Date(visit.plannedStartAt).toISOString().slice(0, 10);
-      await manager.query(`
-        UPDATE inspection_visit_checklist_items item
-        SET
-          item_kind = CASE
-            WHEN finding.status='OPEN'
-              AND finding.next_control_on IS NOT NULL
-              AND finding.next_control_on < $3::date
-              AND COALESCE((
-                SELECT verification.outcome
-                FROM inspection_finding_verification_visits verification
-                WHERE verification.finding_id=finding.id
-                  AND verification.outcome IS NOT NULL
-                ORDER BY verification.result_recorded_at DESC NULLS LAST,
-                         verification.created_at DESC,
-                         verification.id DESC
-                LIMIT 1
-              ), '') <> 'RESOLVED'
-              THEN 'VERIFICATION_OVERDUE'
-            WHEN finding.status='OPEN'
-              AND finding.next_control_on IS NOT NULL
-              AND finding.next_control_on BETWEEN $3::date AND ($3::date + 30)
-              AND COALESCE((
-                SELECT verification.outcome
-                FROM inspection_finding_verification_visits verification
-                WHERE verification.finding_id=finding.id
-                  AND verification.outcome IS NOT NULL
-                ORDER BY verification.result_recorded_at DESC NULLS LAST,
-                         verification.created_at DESC,
-                         verification.id DESC
-                LIMIT 1
-              ), '') <> 'RESOLVED'
-              THEN 'UPCOMING_CONTROL'
-            ELSE 'ANTECEDENT'
-          END,
-          reference_on = CASE
-            WHEN finding.status='OPEN'
-              AND finding.next_control_on IS NOT NULL
-              AND COALESCE((
-                SELECT verification.outcome
-                FROM inspection_finding_verification_visits verification
-                WHERE verification.finding_id=finding.id
-                  AND verification.outcome IS NOT NULL
-                ORDER BY verification.result_recorded_at DESC NULLS LAST,
-                         verification.created_at DESC,
-                         verification.id DESC
-                LIMIT 1
-              ), '') <> 'RESOLVED'
-              THEN finding.next_control_on
-            ELSE NULL
-          END
-        FROM inspection_findings finding
-        WHERE item.visit_id=$1
-          AND item.generation_number=$2
-          AND finding.id=item.finding_id
-      `, [visitId, visit.generation, targetDate]);
-    });
+    const classifications = (await this.f4DataSource.query(`
+      SELECT
+        finding.id AS "findingId",
+        CASE
+          WHEN finding.status='OPEN'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on < $2::date
+            AND COALESCE((
+              SELECT verification.outcome
+              FROM inspection_finding_verification_visits verification
+              WHERE verification.finding_id=finding.id
+                AND verification.outcome IS NOT NULL
+              ORDER BY verification.result_recorded_at DESC NULLS LAST,
+                       verification.created_at DESC,
+                       verification.id DESC
+              LIMIT 1
+            ), '') <> 'RESOLVED'
+            THEN 'VERIFICATION_OVERDUE'
+          WHEN finding.status='OPEN'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on BETWEEN $2::date AND ($2::date + 30)
+            AND COALESCE((
+              SELECT verification.outcome
+              FROM inspection_finding_verification_visits verification
+              WHERE verification.finding_id=finding.id
+                AND verification.outcome IS NOT NULL
+              ORDER BY verification.result_recorded_at DESC NULLS LAST,
+                       verification.created_at DESC,
+                       verification.id DESC
+              LIMIT 1
+            ), '') <> 'RESOLVED'
+            THEN 'UPCOMING_CONTROL'
+          ELSE 'ANTECEDENT'
+        END AS "itemKind",
+        CASE
+          WHEN finding.status='OPEN'
+            AND finding.next_control_on IS NOT NULL
+            AND COALESCE((
+              SELECT verification.outcome
+              FROM inspection_finding_verification_visits verification
+              WHERE verification.finding_id=finding.id
+                AND verification.outcome IS NOT NULL
+              ORDER BY verification.result_recorded_at DESC NULLS LAST,
+                       verification.created_at DESC,
+                       verification.id DESC
+              LIMIT 1
+            ), '') <> 'RESOLVED'
+            THEN finding.next_control_on::text
+          ELSE NULL
+        END AS "referenceOn"
+      FROM inspection_findings finding
+      WHERE finding.id=ANY($1::uuid[])
+    `, [findingIds, targetDate])) as F4ChecklistClassification[];
+
+    const byFinding = new Map(classifications.map((item) => [item.findingId, item]));
+    visit.checklist = {
+      ...visit.checklist,
+      items: visit.checklist.items.map((item) => {
+        const classification = byFinding.get(item.findingId);
+        return classification
+          ? { ...item, itemKind: classification.itemKind, referenceOn: classification.referenceOn }
+          : item;
+      }),
+    };
+    return visit;
  }
 }
@@ -129,6 +129,7 @@ export class FieldFindingsService {
        visit.id AS "visitId",
        visit.code AS "visitCode",
        visit.status AS "visitStatus",
+        COALESCE(visit.scope_asset_id, visit.operational_area_id) AS "scopeAssetId",
        visit.operational_area_id AS "areaId",
        area.code AS "areaCode",
        area.name AS "areaName",
@@ -139,8 +140,7 @@ export class FieldFindingsService {
        asset_type.code AS "assetTypeCode",
        asset.inventory_family_id AS "inventoryFamilyId",
        (
-          asset.operational_area_id=visit.operational_area_id
-          OR asset.id=visit.operational_area_id
+          asset.id=COALESCE(visit.scope_asset_id, visit.operational_area_id)
          OR EXISTS (
            WITH RECURSIVE ancestors AS (
              SELECT id,parent_id FROM assets WHERE id=asset.parent_id
@@ -148,9 +148,11 @@ export class FieldFindingsService {
              SELECT parent.id,parent.parent_id
              FROM assets parent JOIN ancestors child ON parent.id=child.parent_id
            )
-            SELECT 1 FROM ancestors WHERE id=visit.operational_area_id LIMIT 1
+            SELECT 1 FROM ancestors
+            WHERE id=COALESCE(visit.scope_asset_id, visit.operational_area_id)
+            LIMIT 1
          )
-        ) AS "insideArea",
+        ) AS "insideScope",
        EXISTS (
          SELECT 1
          FROM area_company_relations relation
@@ -213,6 +215,7 @@ export class FieldFindingsService {
      visitId: string;
      visitCode: string;
      visitStatus: string;
+      scopeAssetId: string | null;
      areaId: string | null;
      areaCode: string | null;
      areaName: string | null;
@@ -222,7 +225,7 @@ export class FieldFindingsService {
      assetId: string | null;
      assetTypeCode: string | null;
      inventoryFamilyId: string | null;
-      insideArea: boolean;
+      insideScope: boolean;
      operatorRelationValid: boolean;
      assigned: boolean;
      selected: boolean;
@@ -278,10 +281,10 @@ export class FieldFindingsService {
        message: 'La Instalación/Subinstalación debe tener una clasificación técnica antes de registrar Hallazgos',
      });
    }
-    if (!row.insideArea) {
+    if (!row.insideScope) {
      throw new BadRequestException({
        code: 'FIELD_FINDING_INVENTORY_OUTSIDE_CONTEXT',
-        message: 'El Inventario no pertenece al Área de esta inspección',
+        message: 'El Inventario no pertenece al Yacimiento definido como alcance de esta inspección',
      });
    }
    if (!row.selected) {
@@ -23,6 +23,7 @@ interface MobileVisitContext {
  code: string;
  status: string;
  areaId: string;
+  scopeAssetId: string;
  areaCode: string;
  areaName: string;
  companyId: string;
@@ -80,12 +81,12 @@ export class FieldInventoryService {
    const context = await this.requireVisitContext(visitId, principal, false);
    if (query.parentId) await this.requireParentInContext(query.parentId, context);

-    // Empresa is visit context, never physical ownership. Search by Area ancestry.
-    const args: unknown[] = [context.areaId, visitId];
+    // Empresa is visit context, never physical ownership. Search stays inside the frozen Yacimiento scope.
+    const args: unknown[] = [context.scopeAssetId, visitId];
    const conditions = [
      "asset.information_status <> 'INACTIVE'",
      `(
-        asset.operational_area_id = $1::uuid
+        asset.id = $1::uuid
        OR EXISTS (
          WITH RECURSIVE ancestors AS (
            SELECT id,parent_id FROM assets WHERE id=asset.parent_id
@@ -198,7 +199,7 @@ export class FieldInventoryService {
    principal: AuthPrincipal,
  ) {
    const context = await this.requireVisitContext(visitId, principal, false);
-    const effectiveParentId = parentId ?? context.areaId;
+    const effectiveParentId = parentId ?? context.scopeAssetId;
    const parent = await this.requireParentInContext(effectiveParentId, context);

    const data = await this.dataSource.query(`
@@ -272,7 +273,7 @@ export class FieldInventoryService {
    request: RequestWithContext,
  ) {
    const context = await this.requireVisitContext(visitId, principal, true);
-    const parentId = dto.parentId ?? context.areaId;
+    const parentId = dto.parentId ?? context.scopeAssetId;
    await this.requireParentInContext(parentId, context);

    const capturedAt = new Date(dto.deviceCapturedAt);
@@ -412,6 +413,7 @@ export class FieldInventoryService {
        visit.id,
        visit.code,
        visit.status,
+        COALESCE(visit.scope_asset_id, visit.operational_area_id) AS "scopeAssetId",
        visit.operational_area_id AS "areaId",
        area.code AS "areaCode",
        area.name AS "areaName",
@@ -485,6 +487,7 @@ export class FieldInventoryService {
  private publicContext(context: MobileVisitContext) {
    return {
      inspection: { id: context.id, code: context.code, status: context.status },
+      scopeAssetId: context.scopeAssetId,
      area: { id: context.areaId, code: context.areaCode, name: context.areaName },
      operatorCompany: {
        id: context.companyId,
@@ -503,7 +506,6 @@ export class FieldInventoryService {
        asset.asset_type_id AS "typeId",
        (
          asset.id=$2::uuid
-          OR asset.operational_area_id=$2::uuid
          OR EXISTS (
            WITH RECURSIVE ancestors AS (
              SELECT id,parent_id FROM assets WHERE id=asset.parent_id
@@ -512,16 +514,16 @@ export class FieldInventoryService {
              FROM assets parent JOIN ancestors child ON parent.id=child.parent_id
            ) SELECT 1 FROM ancestors WHERE id=$2::uuid LIMIT 1
          )
-        ) AS "insideArea"
+        ) AS "insideScope"
      FROM assets asset
      WHERE asset.id = $1::uuid
        AND asset.information_status <> 'INACTIVE'
-    `, [parentId, context.areaId])) as Array<{
+    `, [parentId, context.scopeAssetId])) as Array<{
      id: string;
      code: string;
      name: string;
      typeId: string;
-      insideArea: boolean;
+      insideScope: boolean;
    }>;

    if (!parent) {
@@ -530,10 +532,10 @@ export class FieldInventoryService {
        message: 'La ubicación padre no existe',
      });
    }
-    if (!parent.insideArea) {
+    if (!parent.insideScope) {
      throw new BadRequestException({
        code: 'FIELD_INVENTORY_PARENT_OUTSIDE_CONTEXT',
-        message: 'La ubicación padre no pertenece al Área de la inspección',
+        message: 'La ubicación padre no pertenece al Yacimiento definido como alcance de la inspección',
      });
    }
    return parent;
@@ -545,7 +547,7 @@ export class FieldInventoryService {
        asset.id,
        (asset.is_inventory_instance=true OR lower(type.code)='yacimiento') AS "eligibleTarget",
        (
-          asset.operational_area_id=$2::uuid
+          asset.id=$2::uuid
          OR EXISTS (
            WITH RECURSIVE ancestors AS (
              SELECT id,parent_id FROM assets WHERE id=asset.parent_id
@@ -554,15 +556,15 @@ export class FieldInventoryService {
              FROM assets parent JOIN ancestors child ON parent.id=child.parent_id
            ) SELECT 1 FROM ancestors WHERE id=$2::uuid LIMIT 1
          )
-        ) AS "insideArea"
+        ) AS "insideScope"
      FROM assets asset
      JOIN asset_types type ON type.id=asset.asset_type_id
      WHERE asset.id = $1::uuid
        AND asset.information_status <> 'INACTIVE'
-    `, [assetId, context.areaId])) as Array<{
+    `, [assetId, context.scopeAssetId])) as Array<{
      id: string;
      eligibleTarget: boolean;
-      insideArea: boolean;
+      insideScope: boolean;
    }>;

    if (!asset) {
@@ -571,10 +573,10 @@ export class FieldInventoryService {
        message: 'Registro de Inventario no encontrado',
      });
    }
-    if (!asset.insideArea) {
+    if (!asset.insideScope) {
      throw new BadRequestException({
        code: 'FIELD_INVENTORY_OUTSIDE_CONTEXT',
-        message: 'El registro no pertenece al Área de esta inspección',
+        message: 'El registro no pertenece al Yacimiento definido como alcance de esta inspección',
      });
    }
    if (!asset.eligibleTarget) {
@@ -0,0 +1,250 @@
+import { BadRequestException, ConflictException, Injectable, Logger } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { administrationAuditContext, isUniqueViolation } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { AuditAction, InspectionVisit, InspectionVisitStatus } from '../database/entities';
+import type { CreateInspectionVisitDto } from './dto/create-inspection-visit.dto';
+import { nextInspectionVisitCode } from './inspection-visit-code';
+import { validateInspectionPlanningScope } from './inspection-planning-scope';
+import { InspectionVisitsService } from './inspection-visits.service';
+
+/**
+ * Creación WEB F6.1. Separa explícitamente ubicación territorial y alcance:
+ * Departamento → Área → Yacimiento. La Operadora no es un padre físico; se
+ * valida contra la relación temporal vigente del Área para la fecha planificada.
+ */
+@Injectable()
+export class InspectionPlanningCreateService {
+  private readonly logger = new Logger(InspectionPlanningCreateService.name);
+
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly audit: AuditService,
+    private readonly visits: InspectionVisitsService,
+  ) {}
+
+  async create(
+    dto: CreateInspectionVisitDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    const scopeAssetId = dto.scopeAssetId;
+    if (!scopeAssetId) {
+      throw new BadRequestException({
+        code: 'INSPECTION_YACIMIENTO_REQUIRED',
+        message: 'Seleccioná el Yacimiento de la Inspección',
+      });
+    }
+    const plannedStartAt = new Date(dto.plannedStartAt);
+    if (!Number.isFinite(plannedStartAt.getTime())) {
+      throw new BadRequestException({
+        code: 'INSPECTION_START_DATE_REQUIRED',
+        message: 'Indicá una fecha y hora prevista de inicio válida',
+      });
+    }
+
+    let stage = 'transaction:start';
+    try {
+      const visitId = await this.dataSource.transaction(async (manager) => {
+        stage = 'scope:validate';
+        await validateInspectionPlanningScope(manager, dto.operationalAreaId, scopeAssetId);
+
+        stage = 'operator:validate';
+        const [context] = await manager.query(`
+          SELECT relation.id
+          FROM area_company_relations relation
+          INNER JOIN assets area ON area.id=relation.area_id
+          INNER JOIN asset_types area_type ON area_type.id=area.asset_type_id
+          INNER JOIN assets company ON company.id=relation.company_id
+          INNER JOIN asset_types company_type ON company_type.id=company.asset_type_id
+          WHERE relation.area_id=$1::uuid
+            AND relation.company_id=$2::uuid
+            AND relation.relation_role='OPERATOR'
+            AND relation.valid_from <= $3::timestamptz
+            AND (relation.valid_until IS NULL OR relation.valid_until > $3::timestamptz)
+            AND area_type.operational_role='AREA'
+            AND company_type.operational_role='COMPANY'
+            AND area.information_status<>'INACTIVE'
+            AND company.information_status<>'INACTIVE'
+          LIMIT 1
+        `, [dto.operationalAreaId, dto.operatorCompanyId, plannedStartAt]) as Array<{ id: string }>;
+        if (!context) {
+          throw new BadRequestException({
+            code: 'INSPECTION_OPERATOR_NOT_ACTIVE_IN_AREA',
+            message: 'La Operadora seleccionada no está vigente para el Área en la fecha de la Inspección',
+          });
+        }
+
+        stage = 'inspector:validate';
+        const [inspector] = await manager.query(`
+          SELECT user_account.id
+          FROM users user_account
+          WHERE user_account.id=$1::uuid
+            AND user_account.status='ACTIVE'
+            AND EXISTS (
+              SELECT 1
+              FROM user_roles user_role
+              INNER JOIN role_permissions role_permission ON role_permission.role_id=user_role.role_id
+              INNER JOIN permissions permission ON permission.id=role_permission.permission_id
+              WHERE user_role.user_id=user_account.id
+                AND permission.code='inspections.execute'
+            )
+          LIMIT 1
+        `, [dto.leadInspectorUserId]) as Array<{ id: string }>;
+        if (!inspector) {
+          throw new BadRequestException({
+            code: 'INSPECTION_MEMBER_INVALID',
+            message: 'El Inspector responsable no está activo o no tiene permiso de ejecución',
+          });
+        }
+
+        stage = 'code:next';
+        const code = await nextInspectionVisitCode(manager, plannedStartAt);
+        const visit = manager.getRepository(InspectionVisit).create({
+          code,
+          objective: null,
+          status: InspectionVisitStatus.DRAFT,
+          scopeAssetId,
+          operationalAreaId: dto.operationalAreaId,
+          operatorCompanyId: dto.operatorCompanyId,
+          leadInspectorUserId: dto.leadInspectorUserId,
+          plannedStartAt,
+          actualStartedAt: null,
+          actualClosedAt: null,
+          instructions: null,
+          cancellationReason: null,
+          checklistGeneration: 1,
+          checklistGeneratedAt: new Date(),
+          createdBy: principal.userId,
+          updatedBy: principal.userId,
+        });
+
+        stage = 'visit:save';
+        await manager.getRepository(InspectionVisit).save(visit);
+
+        stage = 'member:insert';
+        await manager.query(`
+          INSERT INTO inspection_visit_members (visit_id,user_id,included,assigned_by)
+          VALUES ($1::uuid,$2::uuid,true,$3::uuid)
+        `, [visit.id, dto.leadInspectorUserId, principal.userId]);
+
+        // El checklist sigue el alcance físico del Yacimiento. No usa
+        // assets.operator_company_id, que en F6 es sólo snapshot histórico.
+        stage = 'checklist:insert';
+        await manager.query(`
+          INSERT INTO inspection_visit_checklist_items (
+            visit_id,generation_number,finding_id,asset_id,item_kind,
+            reference_on,finding_status,finding_code,finding_title,severity
+          )
+          SELECT
+            $1::uuid,1,finding.id,finding.asset_id,
+            CASE
+              WHEN finding.status='OPEN'
+                AND finding.next_control_on IS NOT NULL
+                AND finding.next_control_on < $4::date THEN 'VERIFICATION_OVERDUE'
+              WHEN finding.status='OPEN'
+                AND finding.next_control_on IS NOT NULL
+                AND finding.next_control_on BETWEEN $4::date AND ($4::date + 30) THEN 'UPCOMING_CONTROL'
+              ELSE 'ANTECEDENT'
+            END,
+            CASE WHEN finding.next_control_on IS NOT NULL THEN finding.next_control_on ELSE NULL END,
+            finding.status,finding.code,finding.title,finding.severity
+          FROM inspection_findings finding
+          INNER JOIN assets inventory ON inventory.id=finding.asset_id
+          WHERE inventory.operational_area_id=$2::uuid
+            AND finding.status<>'VOIDED'
+            AND EXISTS (
+              WITH RECURSIVE ancestors AS (
+                SELECT current_asset.id,current_asset.parent_id
+                FROM assets current_asset WHERE current_asset.id=finding.asset_id
+                UNION ALL
+                SELECT parent.id,parent.parent_id
+                FROM assets parent INNER JOIN ancestors child ON child.parent_id=parent.id
+              )
+              SELECT 1 FROM ancestors WHERE id=$3::uuid LIMIT 1
+            )
+          ORDER BY finding.created_at,finding.id
+        `, [visit.id, dto.operationalAreaId, scopeAssetId, plannedStartAt.toISOString().slice(0, 10)]);
+
+        stage = 'checklist:assets';
+        await manager.query(`
+          INSERT INTO inspection_visit_assets (
+            visit_id, asset_id, included, planning_source, added_by
+          )
+          SELECT DISTINCT $1::uuid, item.asset_id, true, 'AUTOMATIC', $2::uuid
+          FROM inspection_visit_checklist_items item
+          WHERE item.visit_id=$1::uuid
+            AND item.generation_number=1
+            AND item.item_kind IN ('COMPANY_OVERDUE','VERIFICATION_OVERDUE','UPCOMING_CONTROL')
+          ON CONFLICT (visit_id,asset_id) DO UPDATE SET
+            included=true,
+            planning_source=CASE
+              WHEN inspection_visit_assets.planning_source='VERIFICATION' THEN 'VERIFICATION'
+              ELSE 'AUTOMATIC'
+            END,
+            exclusion_reason=NULL,
+            excluded_by=NULL,
+            excluded_at=NULL,
+            added_by=EXCLUDED.added_by,
+            updated_at=CURRENT_TIMESTAMP
+        `, [visit.id, principal.userId]);
+
+        stage = 'checklist:asset-events';
+        await manager.query(`
+          INSERT INTO inspection_visit_asset_events (
+            visit_id, asset_id, event_type, reason, actor_user_id, metadata
+          )
+          SELECT DISTINCT
+            $1::uuid, item.asset_id, 'AUTO_INCLUDED', NULL, $2::uuid,
+            jsonb_build_object('generation',1,'source','F6.1_CREATE')
+          FROM inspection_visit_checklist_items item
+          WHERE item.visit_id=$1::uuid
+            AND item.generation_number=1
+            AND item.item_kind IN ('COMPANY_OVERDUE','VERIFICATION_OVERDUE','UPCOMING_CONTROL')
+            AND NOT EXISTS (
+              SELECT 1 FROM inspection_visit_asset_events event
+              WHERE event.visit_id=$1::uuid
+                AND event.asset_id=item.asset_id
+                AND event.event_type='AUTO_INCLUDED'
+            )
+        `, [visit.id, principal.userId]);
+
+        stage = 'audit:record';
+        await this.audit.record({
+          ...administrationAuditContext(principal, request),
+          action: AuditAction.INSPECTION_VISIT_CREATED,
+          entityType: 'inspection_visit',
+          entityId: visit.id,
+          afterData: {
+            id: visit.id,
+            code,
+            status: visit.status,
+            departmentHierarchy: 'Departamento → Área → Yacimiento',
+            operationalAreaId: dto.operationalAreaId,
+            scopeAssetId,
+            operatorCompanyId: dto.operatorCompanyId,
+            plannedStartAt: plannedStartAt.toISOString(),
+            leadInspectorUserId: dto.leadInspectorUserId,
+          },
+        }, manager);
+        return visit.id;
+      });
+
+      stage = 'view:load';
+      return await this.visits.getById(visitId);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        throw new ConflictException({
+          code: 'INSPECTION_CODE_ALREADY_EXISTS',
+          message: 'El identificador de Inspección ya existe; volvé a intentar',
+        });
+      }
+      const technical = error instanceof Error
+        ? `${error.name}: ${error.message}${error.stack ? `\n${error.stack}` : ''}`
+        : String(error);
+      this.logger.error(`F6.1 inspection create failed at ${stage}: ${technical}`);
+      throw error;
+    }
+  }
+}
@@ -0,0 +1,109 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+export interface InspectionPlanningHierarchyItem {
+  id: string;
+  code: string;
+  name: string;
+}
+
+@Injectable()
+export class InspectionPlanningHierarchyService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async departments(): Promise<{ data: InspectionPlanningHierarchyItem[] }> {
+    const data = await this.dataSource.query(`
+      SELECT department.id, department.code, department.name
+      FROM assets department
+      INNER JOIN asset_types type ON type.id=department.asset_type_id
+      WHERE lower(type.code)='departamento'
+        AND type.is_active=true
+        AND department.information_status<>'INACTIVE'
+        AND EXISTS (
+          SELECT 1
+          FROM assets area
+          INNER JOIN asset_types area_type ON area_type.id=area.asset_type_id
+          WHERE area.parent_id=department.id
+            AND lower(area_type.code)='area'
+            AND area.information_status<>'INACTIVE'
+        )
+      ORDER BY department.name, department.code
+    `) as InspectionPlanningHierarchyItem[];
+    return { data };
+  }
+
+  async areasForDepartment(departmentId: string): Promise<{ data: InspectionPlanningHierarchyItem[] }> {
+    await this.requireType(departmentId, 'departamento', 'El Departamento seleccionado no es válido');
+    const data = await this.dataSource.query(`
+      SELECT area.id, area.code, area.name
+      FROM assets area
+      INNER JOIN asset_types type ON type.id=area.asset_type_id
+      WHERE area.parent_id=$1::uuid
+        AND lower(type.code)='area'
+        AND type.is_active=true
+        AND area.information_status<>'INACTIVE'
+      ORDER BY area.name, area.code
+    `, [departmentId]) as InspectionPlanningHierarchyItem[];
+    return { data };
+  }
+
+  async yacimientosForArea(areaId: string): Promise<{ data: InspectionPlanningHierarchyItem[] }> {
+    await this.requireType(areaId, 'area', 'El Área seleccionada no es válida');
+    const data = await this.dataSource.query(`
+      SELECT yacimiento.id, yacimiento.code, yacimiento.name
+      FROM assets yacimiento
+      INNER JOIN asset_types type ON type.id=yacimiento.asset_type_id
+      WHERE yacimiento.parent_id=$1::uuid
+        AND lower(type.code)='yacimiento'
+        AND type.is_active=true
+        AND yacimiento.information_status<>'INACTIVE'
+      ORDER BY yacimiento.name, yacimiento.code
+    `, [areaId]) as InspectionPlanningHierarchyItem[];
+    return { data };
+  }
+
+  async operatorsForArea(
+    areaId: string,
+    at?: string,
+  ): Promise<{ data: InspectionPlanningHierarchyItem[] }> {
+    await this.requireType(areaId, 'area', 'El Área seleccionada no es válida');
+    const effectiveAt = at ? new Date(at) : new Date();
+    if (!Number.isFinite(effectiveAt.getTime())) {
+      throw new BadRequestException({
+        code: 'INSPECTION_PLANNING_DATE_INVALID',
+        message: 'La fecha de planificación no es válida',
+      });
+    }
+    const data = await this.dataSource.query(`
+      SELECT DISTINCT company.id, company.code, company.name
+      FROM area_company_relations relation
+      INNER JOIN assets company ON company.id=relation.company_id
+      INNER JOIN asset_types type ON type.id=company.asset_type_id
+      WHERE relation.area_id=$1::uuid
+        AND relation.relation_role='OPERATOR'
+        AND relation.valid_from <= $2::timestamptz
+        AND (relation.valid_until IS NULL OR relation.valid_until > $2::timestamptz)
+        AND type.operational_role='COMPANY'
+        AND type.is_active=true
+        AND company.information_status<>'INACTIVE'
+      ORDER BY company.name, company.code
+    `, [areaId, effectiveAt]) as InspectionPlanningHierarchyItem[];
+    return { data };
+  }
+
+  private async requireType(id: string, typeCode: string, message: string): Promise<void> {
+    const [row] = await this.dataSource.query(`
+      SELECT 1
+      FROM assets asset
+      INNER JOIN asset_types type ON type.id=asset.asset_type_id
+      WHERE asset.id=$1::uuid
+        AND lower(type.code)=lower($2)
+        AND type.is_active=true
+        AND asset.information_status<>'INACTIVE'
+      LIMIT 1
+    `, [id, typeCode]) as Array<{ '?column?': number }>;
+    if (!row) {
+      throw new BadRequestException({ code: 'INSPECTION_PLANNING_HIERARCHY_INVALID', message });
+    }
+  }
+}
@@ -0,0 +1,35 @@
+import { BadRequestException } from '@nestjs/common';
+import type { EntityManager } from 'typeorm';
+
+/**
+ * F6.1 keeps territorial levels explicit. operationalAreaId freezes the Area
+ * context while scopeAssetId identifies the Yacimiento inspected inside it.
+ * Legacy/mobile callers may still use the Area itself as scope until Android
+ * supplies a Yacimiento explicitly.
+ */
+export async function validateInspectionPlanningScope(
+  manager: EntityManager,
+  operationalAreaId: string,
+  scopeAssetId: string,
+): Promise<void> {
+  if (scopeAssetId === operationalAreaId) return;
+
+  const [scope] = await manager.query(`
+    SELECT 1
+    FROM assets yacimiento
+    INNER JOIN asset_types type ON type.id=yacimiento.asset_type_id
+    WHERE yacimiento.id=$1::uuid
+      AND yacimiento.parent_id=$2::uuid
+      AND lower(type.code)='yacimiento'
+      AND type.is_active=true
+      AND yacimiento.information_status<>'INACTIVE'
+    LIMIT 1
+  `, [scopeAssetId, operationalAreaId]) as Array<{ '?column?': number }>;
+
+  if (!scope) {
+    throw new BadRequestException({
+      code: 'INSPECTION_YACIMIENTO_OUTSIDE_AREA',
+      message: 'El Yacimiento seleccionado no pertenece al Área indicada',
+    });
+  }
+}
@@ -23,6 +23,8 @@ import { OpenMobileInspectionDto } from './dto/open-mobile-inspection.dto';
 import { ReplaceInspectionVisitAssetsDto } from './dto/replace-inspection-visit-assets.dto';
 import { ReplaceInspectionVisitTeamDto } from './dto/replace-inspection-visit-team.dto';
 import { UpdateInspectionVisitDto } from './dto/update-inspection-visit.dto';
+import { InspectionPlanningCreateService } from './inspection-planning-create.service';
+import { InspectionPlanningHierarchyService } from './inspection-planning-hierarchy.service';
 import { InspectionVisitLifecycleService } from './inspection-visit-lifecycle.service';
 import { InspectionVisitsService } from './inspection-visits.service';

@@ -31,6 +33,8 @@ export class InspectionVisitsController {
  constructor(
    private readonly visits: InspectionVisitsService,
    private readonly lifecycle: InspectionVisitLifecycleService,
+    private readonly planningHierarchy: InspectionPlanningHierarchyService,
+    private readonly planningCreate: InspectionPlanningCreateService,
  ) {}

  @Get()
@@ -45,6 +49,29 @@ export class InspectionVisitsController {
    return this.visits.listAssignees();
  }

+  @Get('planning-context/departments')
+  @RequirePermissions('inspections.read')
+  planningDepartments() {
+    return this.planningHierarchy.departments();
+  }
+
+  @Get('planning-context/departments/:departmentId/areas')
+  @RequirePermissions('inspections.read')
+  planningAreasForDepartment(
+    @Param('departmentId', new ParseUUIDPipe({ version: '4' })) departmentId: string,
+  ) {
+    return this.planningHierarchy.areasForDepartment(departmentId);
+  }
+
+  @Get('planning-context/areas/:areaId/yacimientos')
+  @RequirePermissions('inspections.read')
+  planningYacimientos(
+    @Param('areaId', new ParseUUIDPipe({ version: '4' })) areaId: string,
+  ) {
+    return this.planningHierarchy.yacimientosForArea(areaId);
+  }
+
+  /** Compatibilidad con clientes anteriores: lista todas las Áreas. */
  @Get('planning-context/areas')
  @RequirePermissions('inspections.read')
  planningAreas() {
@@ -55,8 +82,9 @@ export class InspectionVisitsController {
  @RequirePermissions('inspections.read')
  planningOperators(
    @Param('areaId', new ParseUUIDPipe({ version: '4' })) areaId: string,
+    @Query('at') at?: string,
  ) {
-    return this.visits.listPlanningOperators(areaId);
+    return this.planningHierarchy.operatorsForArea(areaId, at);
  }

  @Get('mobile/planning-context/areas')
@@ -84,8 +112,8 @@ export class InspectionVisitsController {
    @Req() request: RequestWithContext,
  ) {
    assertMobileInspector(principal);
-    // Android no tiene un lifecycle paralelo: crea la visita y delega las
-    // transiciones DRAFT → PLANNED → IN_PROGRESS a los servicios canónicos.
+    // Android conserva por compatibilidad el alcance a nivel Área hasta que su
+    // flujo también solicite Yacimiento. No se mezcla con la creación WEB F6.1.
    const created = await this.visits.create({
      operationalAreaId: dto.operationalAreaId,
      operatorCompanyId: dto.operatorCompanyId,
@@ -109,7 +137,7 @@ export class InspectionVisitsController {
    @CurrentAuth() principal: AuthPrincipal,
    @Req() request: RequestWithContext,
  ) {
-    return this.visits.create(dto, principal, request);
+    return this.planningCreate.create(dto, principal, request);
  }

  @Patch(':id')
@@ -8,6 +8,8 @@ import { FieldFindingsController } from './field-findings.controller';
 import { FieldFindingsService } from './field-findings.service';
 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 { InspectionVisitLifecycleService } from './inspection-visit-lifecycle.service';
 import { InspectionVisitsController } from './inspection-visits.controller';
 import { InspectionVisitsService } from './inspection-visits.service';
@@ -17,6 +19,8 @@ import { InspectionVisitsService } from './inspection-visits.service';
  controllers: [InspectionVisitsController, FieldInventoryController, FieldFindingsController],
  providers: [
    { provide: InspectionVisitsService, useClass: F4InspectionVisitsService },
+    InspectionPlanningCreateService,
+    InspectionPlanningHierarchyService,
    InspectionVisitLifecycleService,
    FieldInventoryService,
    F3FieldInventoryStructureService,
@@ -23,6 +23,7 @@ import type { ReplaceInspectionVisitAssetsDto } from './dto/replace-inspection-v
 import type { ReplaceInspectionVisitTeamDto } from './dto/replace-inspection-visit-team.dto';
 import type { UpdateInspectionVisitDto } from './dto/update-inspection-visit.dto';
 import { nextInspectionVisitCode } from './inspection-visit-code';
+import { validateInspectionPlanningScope } from './inspection-planning-scope';

 export interface InspectionPerson {
  id: string;
@@ -312,7 +313,7 @@ export class InspectionVisitsService {
        }
        const operationalAreaId = dto.operationalAreaId;
        const operatorCompanyId = dto.operatorCompanyId;
-        await this.validatePlanningContext(manager, operationalAreaId, operatorCompanyId);
+        await this.validatePlanningContext(manager, operationalAreaId, operatorCompanyId, plannedStartAt);
        await this.requireAsset(manager, operationalAreaId);
        await this.requireInspectors(manager, [dto.leadInspectorUserId]);
        const code = await nextInspectionVisitCode(manager, plannedStartAt);
@@ -382,29 +383,24 @@ export class InspectionVisitsService {
          ? visit.operatorCompanyId
          : dto.operatorCompanyId;
        const contextTouched = dto.operationalAreaId !== undefined || dto.operatorCompanyId !== undefined;
-        const nextScope = contextTouched
-          ? nextAreaId
-          : dto.scopeAssetId === undefined
-            ? visit.scopeAssetId
-            : dto.scopeAssetId;
-        await this.validatePlanningContext(manager, nextAreaId, nextCompanyId);
+        const nextScope = dto.scopeAssetId === undefined ? visit.scopeAssetId : dto.scopeAssetId;
+        await this.validatePlanningContext(manager, nextAreaId, nextCompanyId, nextStart);
        await this.requireAsset(manager, nextScope);
-        if (contextTouched && nextAreaId && nextCompanyId) {
-          await this.assertCurrentAssetsMatchContext(manager, id, nextAreaId, nextCompanyId);
-        } else if (dto.scopeAssetId !== undefined) {
+        if (nextAreaId && nextScope) {
+          await validateInspectionPlanningScope(manager, nextAreaId, nextScope);
          await this.assertCurrentAssetsInScope(manager, id, nextScope);
        }
        if (dto.objective !== undefined) visit.objective = dto.objective;
        if (contextTouched) {
          visit.operationalAreaId = nextAreaId;
          visit.operatorCompanyId = nextCompanyId;
-          visit.scopeAssetId = nextAreaId;
-        } else if (dto.scopeAssetId !== undefined) {
+        }
+        if (dto.scopeAssetId !== undefined) {
          visit.scopeAssetId = dto.scopeAssetId;
        }
        if (dto.plannedStartAt !== undefined) visit.plannedStartAt = nextStart;
        if (dto.instructions !== undefined) visit.instructions = dto.instructions;
-        if (contextTouched || dto.plannedStartAt !== undefined) visit.checklistGeneratedAt = null;
+        if (contextTouched || dto.scopeAssetId !== undefined || dto.plannedStartAt !== undefined) visit.checklistGeneratedAt = null;
        visit.updatedBy = principal.userId;
        await manager.getRepository(InspectionVisit).save(visit);
        const updated = await this.loadView(manager, id);
@@ -463,11 +459,10 @@ export class InspectionVisitsService {
            message: 'Seleccioná Área y Operadora antes de agregar registros preventivos',
          });
        }
-        await this.assertAssetsMatchContext(
+        await this.assertAssetsInScope(
          manager,
          additions,
-          visit.operationalAreaId,
-          visit.operatorCompanyId,
+          visit.scopeAssetId ?? visit.operationalAreaId,
        );
        for (const assetId of additions) {
          await manager.query(`
@@ -629,11 +624,10 @@ export class InspectionVisitsService {
      if (!visit.operationalAreaId || !visit.operatorCompanyId) {
        throw new BadRequestException({ code: 'INSPECTION_CONTEXT_REQUIRED', message: 'La visita no tiene Área y Operadora definidas' });
      }
-      await this.assertAssetsMatchContext(
+      await this.assertAssetsInScope(
        manager,
        [assetId],
-        visit.operationalAreaId,
-        visit.operatorCompanyId,
+        visit.scopeAssetId ?? visit.operationalAreaId,
      );
      await manager.query(`
        UPDATE inspection_visit_assets
@@ -920,6 +914,7 @@ export class InspectionVisitsService {
    manager: EntityManager,
    operationalAreaId: string | null,
    operatorCompanyId: string | null,
+    effectiveAt: Date | null = null,
  ): Promise<void> {
    if (!operationalAreaId && !operatorCompanyId) return;
    if (!operationalAreaId || !operatorCompanyId) {
@@ -938,8 +933,8 @@ export class InspectionVisitsService {
          WHERE relation.area_id = area.id
            AND relation.company_id = company.id
            AND relation.relation_role = 'OPERATOR'
-            AND relation.valid_from <= CURRENT_TIMESTAMP
-            AND (relation.valid_until IS NULL OR relation.valid_until > CURRENT_TIMESTAMP)
+            AND relation.valid_from <= $3::timestamptz
+            AND (relation.valid_until IS NULL OR relation.valid_until > $3::timestamptz)
        ) AS "activeOperatorRelation"
      FROM assets area
      INNER JOIN asset_types area_type ON area_type.id = area.asset_type_id
@@ -951,7 +946,7 @@ export class InspectionVisitsService {
        AND company_type.operational_role = 'COMPANY'
        AND area.information_status <> 'INACTIVE'
        AND company.information_status <> 'INACTIVE'
-    `, [operationalAreaId, operatorCompanyId])) as Array<{
+    `, [operationalAreaId, operatorCompanyId, effectiveAt ?? new Date()])) as Array<{
      areaId: string;
      companyId: string;
      activeOperatorRelation: boolean;
@@ -970,44 +965,6 @@ export class InspectionVisitsService {
    }
  }

-  private async assertAssetsMatchContext(
-    manager: EntityManager,
-    assetIds: string[],
-    operationalAreaId: string,
-    operatorCompanyId: string,
-  ): Promise<void> {
-    if (assetIds.length === 0) return;
-    const [row] = (await manager.query(`
-      SELECT COUNT(*)::integer AS outside
-      FROM assets asset
-      WHERE asset.id = ANY($1::uuid[])
-        AND (
-          asset.operational_area_id IS DISTINCT FROM $2::uuid
-          OR asset.operator_company_id IS DISTINCT FROM $3::uuid
-        )
-    `, [assetIds, operationalAreaId, operatorCompanyId])) as Array<{ outside: number }>;
-    if (Number(row?.outside ?? 0) > 0) {
-      throw new BadRequestException({
-        code: 'INSPECTION_ASSET_OUTSIDE_OPERATIONAL_CONTEXT',
-        message: 'Uno o más registros no pertenecen al Área y Operadora de la visita',
-      });
-    }
-  }
-
-  private async assertCurrentAssetsMatchContext(
-    manager: EntityManager,
-    visitId: string,
-    operationalAreaId: string,
-    operatorCompanyId: string,
-  ): Promise<void> {
-    await this.assertAssetsMatchContext(
-      manager,
-      await this.activeAssetIds(manager, visitId),
-      operationalAreaId,
-      operatorCompanyId,
-    );
-  }
-
  private async appendAssetEvent(
    manager: EntityManager,
    visitId: string,
@@ -1041,7 +998,7 @@ export class InspectionVisitsService {
        message: 'Indicá la fecha prevista antes de generar el checklist',
      });
    }
-    await this.validatePlanningContext(manager, visit.operationalAreaId, visit.operatorCompanyId);
+    await this.validatePlanningContext(manager, visit.operationalAreaId, visit.operatorCompanyId, visit.plannedStartAt);
    const generation = visit.checklistGeneration + 1;
    await manager.query(`
      INSERT INTO inspection_visit_checklist_items (
@@ -1106,14 +1063,25 @@ export class InspectionVisitsService {
      FROM inspection_findings finding
      INNER JOIN assets asset ON asset.id = finding.asset_id
      WHERE asset.operational_area_id = $3
-        AND asset.operator_company_id = $4
        AND finding.status <> 'VOIDED'
+        AND (
+          asset.id=$4::uuid
+          OR EXISTS (
+            WITH RECURSIVE ancestors AS (
+              SELECT id,parent_id FROM assets WHERE id=asset.parent_id
+              UNION ALL
+              SELECT parent.id,parent.parent_id
+              FROM assets parent JOIN ancestors child ON parent.id=child.parent_id
+            )
+            SELECT 1 FROM ancestors WHERE id=$4::uuid LIMIT 1
+          )
+        )
      ORDER BY finding.created_at, finding.id
    `, [
      visit.id,
      generation,
      visit.operationalAreaId,
-      visit.operatorCompanyId,
+      visit.scopeAssetId ?? visit.operationalAreaId,
      visit.plannedStartAt.toISOString().slice(0, 10),
    ]);

@@ -1295,7 +1263,12 @@ export class InspectionVisitsService {
        message: 'Seleccioná Área y Organización operadora antes de confirmar la planificación',
      });
    }
-    await this.validatePlanningContext(manager, visit.operationalAreaId, visit.operatorCompanyId);
+    await this.validatePlanningContext(
+      manager,
+      visit.operationalAreaId,
+      visit.operatorCompanyId,
+      visit.plannedStartAt,
+    );
    if (!visit.scopeAssetId) {
      throw new BadRequestException({
        code: 'INSPECTION_SCOPE_REQUIRED',
@@ -1350,13 +1323,10 @@ export class InspectionVisitsService {
        message: 'El equipo debe incluir al inspector responsable',
      });
    }
+    // F6.1: Inventory membership is physical (Yacimiento scope).
+    // Company is temporal Area context and must never be reconstructed from
+    // assets.operator_company_id, which is only a creation/historical snapshot.
    await this.assertCurrentAssetsInScope(manager, visit.id, visit.scopeAssetId);
-    await this.assertCurrentAssetsMatchContext(
-      manager,
-      visit.id,
-      visit.operationalAreaId,
-      visit.operatorCompanyId,
-    );
  }

  private async activeAssetIds(manager: EntityManager, visitId: string): Promise<string[]> {