maintenance: corregir diagnóstico Android de solo lectura

Restaura migration:run y deploy-github estándar y elimina la herramienta fresh-start luego de la limpieza exitosa.

api-v3/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhv2-api",
-  "version": "0.20.0-3",
+  "version": "0.21.0-1",
   "private": true,
   "license": "UNLICENSED",
   "scripts": {

api-v3/src/asset-master/asset-master.module.ts

@@ -49,6 +49,12 @@ import { FieldDiscoveryInspectionLinkService } from '../inspection-operations/fi
     AssetRegistryService,
     FieldDiscoveryInspectionLinkService,
   ],
-  exports: [AssetHistoryService],
+  exports: [
+    AssetHistoryService,
+    AssetsService,
+    AssetGeometriesService,
+    AssetMediaService,
+    FieldDiscoveryInspectionLinkService,
+  ],
 })
 export class AssetMasterModule {}

api-v3/src/database/migrations/1789668000000-phase-f2-1-field-inventory.ts

@@ -0,0 +1,197 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+function quoteIdentifier(identifier: string): string {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+export class PhaseF21FieldInventory1789668000000 implements MigrationInterface {
+  name = 'PhaseF21FieldInventory1789668000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE field_inventory_code_sequences (
+        year integer PRIMARY KEY,
+        last_value integer NOT NULL DEFAULT 0,
+        CONSTRAINT chk_field_inventory_code_sequences_year CHECK (year BETWEEN 2000 AND 9999),
+        CONSTRAINT chk_field_inventory_code_sequences_value CHECK (last_value >= 0)
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE asset_field_capture_events (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        visit_id uuid NOT NULL,
+        asset_id uuid NOT NULL,
+        media_id uuid,
+        event_type varchar(24) NOT NULL,
+        device_latitude numeric(9, 6) NOT NULL,
+        device_longitude numeric(9, 6) NOT NULL,
+        device_accuracy_m numeric(12, 3),
+        device_captured_at timestamptz NOT NULL,
+        device_label varchar(255),
+        exif_latitude numeric(9, 6),
+        exif_longitude numeric(9, 6),
+        exif_captured_at timestamptz,
+        created_by uuid NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT fk_asset_field_capture_visit FOREIGN KEY (visit_id)
+          REFERENCES inspection_visits(id) ON DELETE RESTRICT,
+        CONSTRAINT fk_asset_field_capture_asset FOREIGN KEY (asset_id)
+          REFERENCES assets(id) ON DELETE RESTRICT,
+        CONSTRAINT fk_asset_field_capture_media FOREIGN KEY (media_id)
+          REFERENCES asset_media(id) ON DELETE RESTRICT,
+        CONSTRAINT fk_asset_field_capture_created_by FOREIGN KEY (created_by)
+          REFERENCES users(id) ON DELETE RESTRICT,
+        CONSTRAINT chk_asset_field_capture_event_type CHECK (event_type IN ('CREATED','PHOTO')),
+        CONSTRAINT chk_asset_field_capture_device_coordinates CHECK (
+          device_latitude BETWEEN -90 AND 90
+          AND device_longitude BETWEEN -180 AND 180
+        ),
+        CONSTRAINT chk_asset_field_capture_accuracy CHECK (
+          device_accuracy_m IS NULL OR device_accuracy_m BETWEEN 0 AND 100000
+        ),
+        CONSTRAINT chk_asset_field_capture_exif_coordinates CHECK (
+          (exif_latitude IS NULL AND exif_longitude IS NULL)
+          OR (
+            exif_latitude IS NOT NULL
+            AND exif_longitude IS NOT NULL
+            AND exif_latitude BETWEEN -90 AND 90
+            AND exif_longitude BETWEEN -180 AND 180
+          )
+        ),
+        CONSTRAINT chk_asset_field_capture_media_event CHECK (
+          (event_type = 'CREATED' AND media_id IS NULL)
+          OR (event_type = 'PHOTO' AND media_id IS NOT NULL)
+        )
+      )
+    `);
+    await queryRunner.query(`CREATE INDEX idx_asset_field_capture_visit ON asset_field_capture_events (visit_id, created_at, id)`);
+    await queryRunner.query(`CREATE INDEX idx_asset_field_capture_asset ON asset_field_capture_events (asset_id, created_at, id)`);
+    await queryRunner.query(`CREATE UNIQUE INDEX uq_asset_field_capture_media ON asset_field_capture_events (media_id) WHERE media_id IS NOT NULL`);
+
+    await queryRunner.query(`
+      ALTER TABLE inspection_visit_assets
+      DROP CONSTRAINT chk_inspection_visit_assets_planning_source
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_visit_assets
+      ADD CONSTRAINT chk_inspection_visit_assets_planning_source CHECK (
+        planning_source IN ('LEGACY','AUTOMATIC','PREVENTIVE','VERIFICATION','FIELD')
+      )
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE inspection_visit_asset_events
+      DROP CONSTRAINT chk_inspection_visit_asset_events_type
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_visit_asset_events
+      ADD CONSTRAINT chk_inspection_visit_asset_events_type CHECK (
+        event_type IN ('LEGACY_INCLUDED','AUTO_INCLUDED','PREVENTIVE_INCLUDED','VERIFICATION_INCLUDED','FIELD_INCLUDED','EXCLUDED','REINCLUDED')
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION enforce_field_inventory_capture_before_finding()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      DECLARE
+        finding_visit_id uuid;
+      BEGIN
+        SELECT act.visit_id INTO finding_visit_id
+        FROM inspection_acts act
+        WHERE act.id = NEW.act_id;
+
+        IF finding_visit_id IS NULL THEN
+          RETURN NEW;
+        END IF;
+
+        IF EXISTS (
+          SELECT 1
+          FROM asset_field_discoveries discovery
+          WHERE discovery.visit_id = finding_visit_id
+            AND discovery.asset_id = NEW.asset_id
+        ) THEN
+          IF NOT EXISTS (
+            SELECT 1
+            FROM asset_field_capture_events capture
+            WHERE capture.visit_id = finding_visit_id
+              AND capture.asset_id = NEW.asset_id
+              AND capture.event_type = 'CREATED'
+          ) THEN
+            RAISE EXCEPTION USING
+              ERRCODE = '23514',
+              MESSAGE = 'FIELD_INVENTORY_GPS_REQUIRED';
+          END IF;
+
+          IF NOT EXISTS (
+            SELECT 1
+            FROM asset_field_capture_events capture
+            WHERE capture.visit_id = finding_visit_id
+              AND capture.asset_id = NEW.asset_id
+              AND capture.event_type = 'PHOTO'
+          ) THEN
+            RAISE EXCEPTION USING
+              ERRCODE = '23514',
+              MESSAGE = 'FIELD_INVENTORY_PHOTO_REQUIRED';
+          END IF;
+        END IF;
+
+        RETURN NEW;
+      END
+      $$
+    `);
+    await queryRunner.query(`
+      CREATE TRIGGER trg_inspection_findings_field_capture
+      BEFORE INSERT OR UPDATE OF act_id, asset_id ON inspection_findings
+      FOR EACH ROW
+      EXECUTE FUNCTION enforce_field_inventory_capture_before_finding()
+    `);
+
+    const appRole = process.env.DB_APP_USER;
+    if (!appRole) throw new Error('Missing required environment variable: DB_APP_USER');
+    const applicationRole = quoteIdentifier(appRole);
+    await queryRunner.query(`GRANT SELECT, INSERT, UPDATE ON TABLE field_inventory_code_sequences TO ${applicationRole}`);
+    await queryRunner.query(`GRANT SELECT, INSERT ON TABLE asset_field_capture_events TO ${applicationRole}`);
+    await queryRunner.query(`REVOKE UPDATE, DELETE ON TABLE asset_field_capture_events FROM ${applicationRole}`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF EXISTS (SELECT 1 FROM asset_field_capture_events LIMIT 1) THEN
+          RAISE EXCEPTION 'F2.1 no puede revertirse: existen capturas GPS/EXIF de campo';
+        END IF;
+        IF EXISTS (SELECT 1 FROM inspection_visit_assets WHERE planning_source = 'FIELD' LIMIT 1) THEN
+          RAISE EXCEPTION 'F2.1 no puede revertirse: existen registros seleccionados o creados en campo';
+        END IF;
+        IF EXISTS (SELECT 1 FROM inspection_visit_asset_events WHERE event_type = 'FIELD_INCLUDED' LIMIT 1) THEN
+          RAISE EXCEPTION 'F2.1 no puede revertirse: existen eventos de Inventario de campo';
+        END IF;
+      END
+      $$
+    `);
+
+    await queryRunner.query(`DROP TRIGGER IF EXISTS trg_inspection_findings_field_capture ON inspection_findings`);
+    await queryRunner.query(`DROP FUNCTION IF EXISTS enforce_field_inventory_capture_before_finding()`);
+
+    await queryRunner.query(`ALTER TABLE inspection_visit_asset_events DROP CONSTRAINT chk_inspection_visit_asset_events_type`);
+    await queryRunner.query(`
+      ALTER TABLE inspection_visit_asset_events
+      ADD CONSTRAINT chk_inspection_visit_asset_events_type CHECK (
+        event_type IN ('LEGACY_INCLUDED','AUTO_INCLUDED','PREVENTIVE_INCLUDED','VERIFICATION_INCLUDED','EXCLUDED','REINCLUDED')
+      )
+    `);
+    await queryRunner.query(`ALTER TABLE inspection_visit_assets DROP CONSTRAINT chk_inspection_visit_assets_planning_source`);
+    await queryRunner.query(`
+      ALTER TABLE inspection_visit_assets
+      ADD CONSTRAINT chk_inspection_visit_assets_planning_source CHECK (
+        planning_source IN ('LEGACY','AUTOMATIC','PREVENTIVE','VERIFICATION')
+      )
+    `);
+    await queryRunner.query(`DROP TABLE asset_field_capture_events`);
+    await queryRunner.query(`DROP TABLE field_inventory_code_sequences`);
+  }
+}

api-v3/src/inspection-operations/field-discovery-inspection-link.service.ts

@@ -26,19 +26,60 @@ export class FieldDiscoveryInspectionLinkService {
       [visitId],
     )) as Array<{ id: string; status: string }>;
 
+    const [existing] = (await manager.query(
+      `
+        SELECT included, planning_source AS "planningSource"
+        FROM inspection_visit_assets
+        WHERE visit_id = $1 AND asset_id = $2
+        FOR UPDATE
+      `,
+      [visitId, assetId],
+    )) as Array<{ included: boolean; planningSource: string }>;
 
     await manager.query(
       `
-        INSERT INTO inspection_visit_assets (visit_id, asset_id, included, added_by)
-        VALUES ($1, $2, true, $3)
+        INSERT INTO inspection_visit_assets (
+          visit_id, asset_id, included, planning_source, added_by,
+          exclusion_reason, excluded_by, excluded_at
+        )
+        VALUES ($1, $2, true, 'FIELD', $3, NULL, NULL, NULL)
         ON CONFLICT (visit_id, asset_id) DO UPDATE SET
           included = true,
+          planning_source = CASE
+            WHEN inspection_visit_assets.planning_source IN ('AUTOMATIC','VERIFICATION')
+              THEN inspection_visit_assets.planning_source
+            ELSE 'FIELD'
+          END,
           added_by = EXCLUDED.added_by,
+          exclusion_reason = NULL,
+          excluded_by = NULL,
+          excluded_at = NULL,
           updated_at = CURRENT_TIMESTAMP
       `,
       [visitId, assetId, userId],
     );
 
+    const eventType = existing && existing.included ? null : 'FIELD_INCLUDED';
+    if (eventType) {
+      await manager.query(
+        `
+          INSERT INTO inspection_visit_asset_events (
+            visit_id, asset_id, event_type, actor_user_id, metadata
+          )
+          VALUES ($1, $2, 'FIELD_INCLUDED', $3, $4::jsonb)
+        `,
+        [
+          visitId,
+          assetId,
+          userId,
+          JSON.stringify({
+            fieldSelection: true,
+            previousPlanningSource: existing?.planningSource ?? null,
+          }),
+        ],
+      );
+    }
+
     if (act) {
       await manager.query(
         `

api-v3/src/inspection-visits/dto/create-field-inventory.dto.ts

@@ -0,0 +1,85 @@
+import { Transform, Type } from 'class-transformer';
+import {
+  IsISO8601,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Matches,
+  Max,
+  MaxLength,
+  Min,
+  MinLength,
+} from 'class-validator';
+
+export class CreateFieldInventoryDto {
+  @IsUUID('4')
+  typeId!: string;
+
+  @IsOptional()
+  @IsUUID('4')
+  parentId?: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim().toUpperCase() : undefined)
+  @IsString()
+  @MaxLength(120)
+  @Matches(/^[A-Z0-9][A-Z0-9._/-]*$/)
+  code?: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(1)
+  @MaxLength(200)
+  name!: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(200)
+  commonName?: string | null;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(4000)
+  description?: string | null;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(4000)
+  discoveryNotes?: string | null;
+
+  @IsObject()
+  attributes!: Record<string, unknown>;
+
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 6 })
+  @Min(-90)
+  @Max(90)
+  deviceLatitude!: number;
+
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 6 })
+  @Min(-180)
+  @Max(180)
+  deviceLongitude!: number;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 3 })
+  @Min(0)
+  @Max(100000)
+  deviceAccuracyM?: number;
+
+  @IsISO8601({ strict: true })
+  deviceCapturedAt!: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(255)
+  deviceLabel?: string | null;
+}

api-v3/src/inspection-visits/dto/list-field-inventory-query.dto.ts

@@ -0,0 +1,25 @@
+import { Transform, Type } from 'class-transformer';
+import { IsInt, IsOptional, IsString, IsUUID, Max, MaxLength, Min } from 'class-validator';
+
+export class ListFieldInventoryQueryDto {
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : undefined)
+  @IsString()
+  @MaxLength(200)
+  search?: string;
+
+  @IsOptional()
+  @IsUUID('4')
+  parentId?: string;
+
+  @IsOptional()
+  @IsUUID('4')
+  typeId?: string;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit = 50;
+}

api-v3/src/inspection-visits/dto/upload-field-inventory-photo.dto.ts

@@ -0,0 +1,70 @@
+import { Transform, Type } from 'class-transformer';
+import {
+  IsISO8601,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Max,
+  MaxLength,
+  Min,
+} from 'class-validator';
+
+export class UploadFieldInventoryPhotoDto {
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(200)
+  title?: string | null;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(4000)
+  description?: string | null;
+
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 6 })
+  @Min(-90)
+  @Max(90)
+  deviceLatitude!: number;
+
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 6 })
+  @Min(-180)
+  @Max(180)
+  deviceLongitude!: number;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 3 })
+  @Min(0)
+  @Max(100000)
+  deviceAccuracyM?: number;
+
+  @IsISO8601({ strict: true })
+  deviceCapturedAt!: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(255)
+  deviceLabel?: string | null;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 6 })
+  @Min(-90)
+  @Max(90)
+  exifLatitude?: number;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber({ maxDecimalPlaces: 6 })
+  @Min(-180)
+  @Max(180)
+  exifLongitude?: number;
+
+  @IsOptional()
+  @IsISO8601({ strict: true })
+  exifCapturedAt?: string;
+}

api-v3/src/inspection-visits/field-inventory.controller.ts

@@ -0,0 +1,93 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Post,
+  Query,
+  Req,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
+import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
+import { MAX_ASSET_MEDIA_BYTES, type UploadedAssetFile } from '../asset-master/asset-media-file';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { CreateFieldInventoryDto } from './dto/create-field-inventory.dto';
+import { ListFieldInventoryQueryDto } from './dto/list-field-inventory-query.dto';
+import { UploadFieldInventoryPhotoDto } from './dto/upload-field-inventory-photo.dto';
+import { FieldInventoryService } from './field-inventory.service';
+
+@Controller('inspection-visits/:visitId/field-inventory')
+export class FieldInventoryController {
+  constructor(private readonly fieldInventory: FieldInventoryService) {}
+
+  @Get()
+  @RequirePermissions('assets.read', 'inspections.execute')
+  list(
+    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
+    @Query() query: ListFieldInventoryQueryDto,
+    @CurrentAuth() principal: AuthPrincipal,
+  ) {
+    return this.fieldInventory.list(visitId, query, principal);
+  }
+
+  @Get('types')
+  @RequirePermissions('assets.read', 'inspections.execute')
+  types(
+    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
+    @Query() query: ListFieldInventoryQueryDto,
+    @CurrentAuth() principal: AuthPrincipal,
+  ) {
+    return this.fieldInventory.types(visitId, query.parentId, principal);
+  }
+
+  @Get(':assetId')
+  @RequirePermissions('assets.read', 'inspections.execute')
+  detail(
+    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
+    @Param('assetId', new ParseUUIDPipe({ version: '4' })) assetId: string,
+    @CurrentAuth() principal: AuthPrincipal,
+  ) {
+    return this.fieldInventory.detail(visitId, assetId, principal);
+  }
+
+  @Post(':assetId/select')
+  @RequirePermissions('assets.read', 'inspections.execute')
+  selectExisting(
+    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
+    @Param('assetId', new ParseUUIDPipe({ version: '4' })) assetId: string,
+    @CurrentAuth() principal: AuthPrincipal,
+  ) {
+    return this.fieldInventory.selectExisting(visitId, assetId, principal);
+  }
+
+  @Post()
+  @RequirePermissions('assets.create', 'inspections.execute')
+  create(
+    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
+    @Body() dto: CreateFieldInventoryDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.fieldInventory.create(visitId, dto, principal, request);
+  }
+
+  @Post(':assetId/photos')
+  @RequirePermissions('assets.create', 'inspections.execute')
+  @UseInterceptors(FileInterceptor('file', {
+    limits: { fileSize: MAX_ASSET_MEDIA_BYTES, files: 1 },
+  }))
+  uploadPhoto(
+    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
+    @Param('assetId', new ParseUUIDPipe({ version: '4' })) assetId: string,
+    @Body() dto: UploadFieldInventoryPhotoDto,
+    @UploadedFile() file: UploadedAssetFile | undefined,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.fieldInventory.uploadPhoto(visitId, assetId, dto, file, principal, request);
+  }
+}

api-v3/src/inspection-visits/field-inventory.service.ts

@@ -0,0 +1,648 @@
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { AssetGeometriesService } from '../asset-master/asset-geometries.service';
+import { AssetMediaService, type AssetMediaView } from '../asset-master/asset-media.service';
+import { AssetsService } from '../asset-master/assets.service';
+import type { UploadedAssetFile } from '../asset-master/asset-media-file';
+import type { CreateFieldDiscoveryDto } from '../asset-master/dto/create-field-discovery.dto';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { AssetGeometryType, AssetMediaKind } from '../database/entities';
+import { FieldDiscoveryInspectionLinkService } from '../inspection-operations/field-discovery-inspection-link.service';
+import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
+import type { CreateFieldInventoryDto } from './dto/create-field-inventory.dto';
+import type { ListFieldInventoryQueryDto } from './dto/list-field-inventory-query.dto';
+import type { UploadFieldInventoryPhotoDto } from './dto/upload-field-inventory-photo.dto';
+
+interface MobileVisitContext {
+  id: string;
+  code: string;
+  status: string;
+  areaId: string;
+  areaCode: string;
+  areaName: string;
+  companyId: string;
+  companyCode: string;
+  companyName: string;
+  assigned: boolean;
+}
+
+interface FieldDiscoveryCreated {
+  id: string;
+  asset: {
+    id: string;
+    code: string;
+    name: string;
+    informationStatus: string;
+  };
+}
+
+export interface FieldInventoryCaptureStatus {
+  captureRequired: boolean;
+  hasGeometry: boolean;
+  creationGpsCaptured: boolean;
+  fieldPhotoCount: number;
+  readyForFinding: boolean;
+  latestDeviceCapture: {
+    latitude: number;
+    longitude: number;
+    accuracyM: number | null;
+    capturedAt: Date;
+    deviceLabel: string | null;
+  } | null;
+  latestPhotoExif: {
+    latitude: number | null;
+    longitude: number | null;
+    capturedAt: Date | null;
+  } | null;
+}
+
+@Injectable()
+export class FieldInventoryService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly assets: AssetsService,
+    private readonly geometries: AssetGeometriesService,
+    private readonly media: AssetMediaService,
+    private readonly links: FieldDiscoveryInspectionLinkService,
+  ) {}
+
+  async list(
+    visitId: string,
+    query: ListFieldInventoryQueryDto,
+    principal: AuthPrincipal,
+  ) {
+    const context = await this.requireVisitContext(visitId, principal, false);
+    if (query.parentId) await this.requireParentInContext(query.parentId, context);
+
+    const args: unknown[] = [context.areaId, context.companyId, visitId];
+    const conditions = [
+      'asset.operational_area_id = $1::uuid',
+      'asset.operator_company_id = $2::uuid',
+      "asset.information_status <> 'INACTIVE'",
+    ];
+
+    if (query.search?.trim()) {
+      args.push(`%${query.search.trim()}%`);
+      const p = `$${args.length}`;
+      conditions.push(`(
+        asset.code ILIKE ${p}
+        OR asset.name ILIKE ${p}
+        OR asset.common_name ILIKE ${p}
+        OR EXISTS (
+          SELECT 1
+          FROM asset_attribute_values value
+          JOIN asset_attribute_definitions definition ON definition.id = value.definition_id
+          WHERE value.asset_id = asset.id
+            AND definition.is_active = true
+            AND (value.value #>> '{}') ILIKE ${p}
+        )
+      )`);
+    }
+
+    if (query.parentId) {
+      args.push(query.parentId);
+      conditions.push(`asset.parent_id = $${args.length}::uuid`);
+    }
+    if (query.typeId) {
+      args.push(query.typeId);
+      conditions.push(`asset.asset_type_id = $${args.length}::uuid`);
+    }
+
+    args.push(query.limit);
+    const limit = `$${args.length}`;
+    const data = await this.dataSource.query(`
+      SELECT
+        asset.id,
+        asset.code,
+        asset.name,
+        asset.common_name AS "commonName",
+        asset.information_status AS "informationStatus",
+        asset.data_origin AS "dataOrigin",
+        JSONB_BUILD_OBJECT('id', type.id, 'code', type.code, 'name', type.name) AS type,
+        CASE WHEN parent.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
+          'id', parent.id, 'code', parent.code, 'name', parent.name
+        ) END AS parent,
+        EXISTS (
+          SELECT 1 FROM inspection_visit_assets link
+          WHERE link.visit_id = $3::uuid
+            AND link.asset_id = asset.id
+            AND link.included = true
+        ) AS "selectedInInspection",
+        EXISTS (
+          SELECT 1 FROM asset_field_discoveries discovery
+          WHERE discovery.visit_id = $3::uuid AND discovery.asset_id = asset.id
+        ) AS "captureRequired",
+        EXISTS (
+          SELECT 1 FROM asset_geometries geometry WHERE geometry.asset_id = asset.id
+        ) AS "hasGeometry",
+        (
+          SELECT COUNT(*)::integer
+          FROM asset_field_capture_events capture
+          WHERE capture.visit_id = $3::uuid
+            AND capture.asset_id = asset.id
+            AND capture.event_type = 'PHOTO'
+        ) AS "fieldPhotoCount",
+        (
+          NOT EXISTS (
+            SELECT 1 FROM asset_field_discoveries discovery
+            WHERE discovery.visit_id = $3::uuid AND discovery.asset_id = asset.id
+          )
+          OR (
+            EXISTS (SELECT 1 FROM asset_geometries geometry WHERE geometry.asset_id = asset.id)
+            AND EXISTS (
+              SELECT 1 FROM asset_field_capture_events capture
+              WHERE capture.visit_id = $3::uuid
+                AND capture.asset_id = asset.id
+                AND capture.event_type = 'CREATED'
+            )
+            AND EXISTS (
+              SELECT 1 FROM asset_field_capture_events capture
+              WHERE capture.visit_id = $3::uuid
+                AND capture.asset_id = asset.id
+                AND capture.event_type = 'PHOTO'
+            )
+          )
+        ) AS "readyForFinding"
+      FROM assets asset
+      JOIN asset_types type ON type.id = asset.asset_type_id
+      LEFT JOIN assets parent ON parent.id = asset.parent_id
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY asset.name, asset.code
+      LIMIT ${limit}
+    `, args);
+
+    return { context: this.publicContext(context), data };
+  }
+
+  async types(
+    visitId: string,
+    parentId: string | undefined,
+    principal: AuthPrincipal,
+  ) {
+    const context = await this.requireVisitContext(visitId, principal, false);
+    const effectiveParentId = parentId ?? context.areaId;
+    const parent = await this.requireParentInContext(effectiveParentId, context);
+
+    const data = await this.dataSource.query(`
+      SELECT
+        type.id,
+        type.code,
+        type.name,
+        type.description,
+        COALESCE(
+          JSONB_AGG(
+            JSONB_BUILD_OBJECT(
+              'id', definition.id,
+              'code', definition.code,
+              'name', definition.name,
+              'dataType', definition.data_type,
+              'isRequired', definition.is_required,
+              'unit', definition.unit,
+              'options', definition.options,
+              'sortOrder', definition.sort_order
+            ) ORDER BY definition.sort_order, definition.name
+          ) FILTER (WHERE definition.id IS NOT NULL),
+          '[]'::jsonb
+        ) AS attributes
+      FROM asset_type_parent_rules rule
+      JOIN asset_types type ON type.id = rule.child_type_id
+      LEFT JOIN asset_attribute_definitions definition
+        ON definition.asset_type_id = type.id
+       AND definition.is_active = true
+      WHERE rule.parent_type_id = $1::uuid
+        AND type.is_active = true
+        AND type.operational_role = 'GENERIC'
+      GROUP BY type.id, type.code, type.name, type.description
+      ORDER BY type.name, type.code
+    `, [parent.typeId]);
+
+    return {
+      context: this.publicContext(context),
+      parent: { id: parent.id, code: parent.code, name: parent.name },
+      data,
+    };
+  }
+
+  async detail(visitId: string, assetId: string, principal: AuthPrincipal) {
+    const context = await this.requireVisitContext(visitId, principal, false);
+    await this.requireAssetInContext(assetId, context);
+    return {
+      context: this.publicContext(context),
+      asset: await this.assets.getById(assetId),
+      selectedInInspection: await this.isSelected(visitId, assetId),
+      capture: await this.captureStatus(visitId, assetId),
+    };
+  }
+
+  async selectExisting(
+    visitId: string,
+    assetId: string,
+    principal: AuthPrincipal,
+  ) {
+    const context = await this.requireVisitContext(visitId, principal, true);
+    await this.requireAssetInContext(assetId, context);
+    await this.dataSource.transaction((manager) =>
+      this.links.attach(manager, visitId, assetId, principal.userId),
+    );
+    return this.detail(visitId, assetId, principal);
+  }
+
+  async create(
+    visitId: string,
+    dto: CreateFieldInventoryDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    const context = await this.requireVisitContext(visitId, principal, true);
+    const parentId = dto.parentId ?? context.areaId;
+    await this.requireParentInContext(parentId, context);
+
+    const capturedAt = new Date(dto.deviceCapturedAt);
+    if (!Number.isFinite(capturedAt.getTime())) {
+      throw new BadRequestException({
+        code: 'FIELD_INVENTORY_INVALID_CAPTURE_DATE',
+        message: 'La fecha de captura del dispositivo no es válida',
+      });
+    }
+
+    const code = dto.code?.trim().toUpperCase() || await this.nextFieldCode(capturedAt);
+    const discoveryDto: CreateFieldDiscoveryDto = {
+      visitId,
+      code,
+      name: dto.name,
+      commonName: dto.commonName ?? null,
+      typeId: dto.typeId,
+      parentId,
+      operationalAreaId: context.areaId,
+      operatorCompanyId: context.companyId,
+      description: dto.description ?? null,
+      discoveryNotes: dto.discoveryNotes ?? null,
+      attributes: dto.attributes,
+    };
+
+    const discovery = await this.assets.createFieldDiscovery(
+      discoveryDto,
+      principal,
+      request,
+    ) as FieldDiscoveryCreated;
+    const assetId = discovery.asset?.id;
+    if (!assetId) {
+      throw new Error('El alta de campo no devolvió el identificador del Inventario creado');
+    }
+
+    await this.geometries.upsert(assetId, {
+      geometry: {
+        type: AssetGeometryType.POINT,
+        coordinates: [dto.deviceLongitude, dto.deviceLatitude],
+      },
+      accuracyM: dto.deviceAccuracyM ?? null,
+      capturedAt: dto.deviceCapturedAt,
+      deviceLabel: dto.deviceLabel ?? null,
+    }, principal, request);
+
+    await this.dataSource.query(`
+      INSERT INTO asset_field_capture_events (
+        visit_id, asset_id, event_type,
+        device_latitude, device_longitude, device_accuracy_m,
+        device_captured_at, device_label, created_by
+      ) VALUES ($1,$2,'CREATED',$3,$4,$5,$6,$7,$8)
+    `, [
+      visitId,
+      assetId,
+      dto.deviceLatitude,
+      dto.deviceLongitude,
+      dto.deviceAccuracyM ?? null,
+      capturedAt,
+      dto.deviceLabel ?? null,
+      principal.userId,
+    ]);
+
+    return this.detail(visitId, assetId, principal);
+  }
+
+  async uploadPhoto(
+    visitId: string,
+    assetId: string,
+    dto: UploadFieldInventoryPhotoDto,
+    file: UploadedAssetFile | undefined,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ): Promise<{ media: AssetMediaView; capture: FieldInventoryCaptureStatus }> {
+    const context = await this.requireVisitContext(visitId, principal, true);
+    await this.requireAssetInContext(assetId, context);
+    if (!await this.isSelected(visitId, assetId)) {
+      throw new ConflictException({
+        code: 'FIELD_INVENTORY_NOT_SELECTED',
+        message: 'Seleccioná el registro dentro de la inspección antes de agregar fotografías',
+      });
+    }
+
+    const exifHasLatitude = dto.exifLatitude !== undefined;
+    const exifHasLongitude = dto.exifLongitude !== undefined;
+    if (exifHasLatitude !== exifHasLongitude) {
+      throw new BadRequestException({
+        code: 'FIELD_PHOTO_EXIF_COORDINATES_INCOMPLETE',
+        message: 'Las coordenadas EXIF deben incluir latitud y longitud juntas',
+      });
+    }
+
+    const uploaded = await this.media.upload(assetId, {
+      kind: AssetMediaKind.PHOTO,
+      title: dto.title ?? undefined,
+      description: dto.description ?? undefined,
+      capturedAt: dto.deviceCapturedAt,
+      latitude: dto.deviceLatitude,
+      longitude: dto.deviceLongitude,
+      accuracyM: dto.deviceAccuracyM,
+    }, file, principal, request);
+
+    await this.dataSource.query(`
+      INSERT INTO asset_field_capture_events (
+        visit_id, asset_id, media_id, event_type,
+        device_latitude, device_longitude, device_accuracy_m,
+        device_captured_at, device_label,
+        exif_latitude, exif_longitude, exif_captured_at,
+        created_by
+      ) VALUES ($1,$2,$3,'PHOTO',$4,$5,$6,$7,$8,$9,$10,$11,$12)
+    `, [
+      visitId,
+      assetId,
+      uploaded.id,
+      dto.deviceLatitude,
+      dto.deviceLongitude,
+      dto.deviceAccuracyM ?? null,
+      new Date(dto.deviceCapturedAt),
+      dto.deviceLabel ?? null,
+      dto.exifLatitude ?? null,
+      dto.exifLongitude ?? null,
+      dto.exifCapturedAt ? new Date(dto.exifCapturedAt) : null,
+      principal.userId,
+    ]);
+
+    return { media: uploaded, capture: await this.captureStatus(visitId, assetId) };
+  }
+
+  private async requireVisitContext(
+    visitId: string,
+    principal: AuthPrincipal,
+    requireInProgress: boolean,
+  ): Promise<MobileVisitContext> {
+    assertMobileInspector(principal);
+    const [context] = (await this.dataSource.query(`
+      SELECT
+        visit.id,
+        visit.code,
+        visit.status,
+        visit.operational_area_id AS "areaId",
+        area.code AS "areaCode",
+        area.name AS "areaName",
+        visit.operator_company_id AS "companyId",
+        company.code AS "companyCode",
+        company.name AS "companyName",
+        (
+          visit.lead_inspector_user_id = $2::uuid
+          OR EXISTS (
+            SELECT 1
+            FROM inspection_visit_members member
+            WHERE member.visit_id = visit.id
+              AND member.user_id = $2::uuid
+              AND member.included = true
+          )
+        ) AS assigned
+      FROM inspection_visits visit
+      LEFT JOIN assets area ON area.id = visit.operational_area_id
+      LEFT JOIN assets company ON company.id = visit.operator_company_id
+      WHERE visit.id = $1::uuid
+    `, [visitId, principal.userId])) as MobileVisitContext[];
+
+    if (!context) {
+      throw new NotFoundException({ code: 'INSPECTION_VISIT_NOT_FOUND', message: 'Inspección no encontrada' });
+    }
+    if (!context.areaId || !context.companyId) {
+      throw new ConflictException({
+        code: 'FIELD_INVENTORY_CONTEXT_REQUIRED',
+        message: 'La inspección no tiene Área y Operadora definidas',
+      });
+    }
+    if (!context.assigned) {
+      throw new ConflictException({
+        code: 'FIELD_INVENTORY_INSPECTOR_NOT_ASSIGNED',
+        message: 'El inspector no está asignado a esta inspección',
+      });
+    }
+    if (requireInProgress && context.status !== 'IN_PROGRESS') {
+      throw new ConflictException({
+        code: 'FIELD_INVENTORY_VISIT_NOT_IN_PROGRESS',
+        message: 'El Inventario sólo puede modificarse cuando la inspección está en curso',
+      });
+    }
+    if (!requireInProgress && !['PLANNED', 'IN_PROGRESS'].includes(context.status)) {
+      throw new ConflictException({
+        code: 'FIELD_INVENTORY_VISIT_NOT_AVAILABLE',
+        message: 'El Inventario de campo está disponible para inspecciones planificadas o en curso',
+      });
+    }
+    return context;
+  }
+
+  private publicContext(context: MobileVisitContext) {
+    return {
+      inspection: { id: context.id, code: context.code, status: context.status },
+      area: { id: context.areaId, code: context.areaCode, name: context.areaName },
+      operatorCompany: {
+        id: context.companyId,
+        code: context.companyCode,
+        name: context.companyName,
+      },
+    };
+  }
+
+  private async requireParentInContext(parentId: string, context: MobileVisitContext) {
+    const [parent] = (await this.dataSource.query(`
+      SELECT
+        asset.id,
+        asset.code,
+        asset.name,
+        asset.asset_type_id AS "typeId",
+        asset.operational_area_id AS "areaId",
+        asset.operator_company_id AS "companyId"
+      FROM assets asset
+      WHERE asset.id = $1::uuid
+        AND asset.information_status <> 'INACTIVE'
+    `, [parentId])) as Array<{
+      id: string;
+      code: string;
+      name: string;
+      typeId: string;
+      areaId: string | null;
+      companyId: string | null;
+    }>;
+
+    if (!parent) {
+      throw new NotFoundException({
+        code: 'FIELD_INVENTORY_PARENT_NOT_FOUND',
+        message: 'La ubicación padre no existe',
+      });
+    }
+    if (
+      parent.id !== context.areaId
+      && (parent.areaId !== context.areaId || parent.companyId !== context.companyId)
+    ) {
+      throw new BadRequestException({
+        code: 'FIELD_INVENTORY_PARENT_OUTSIDE_CONTEXT',
+        message: 'La ubicación padre no pertenece al Área y Operadora de la inspección',
+      });
+    }
+    return parent;
+  }
+
+  private async requireAssetInContext(assetId: string, context: MobileVisitContext) {
+    const [asset] = (await this.dataSource.query(`
+      SELECT id,
+             operational_area_id AS "areaId",
+             operator_company_id AS "companyId"
+      FROM assets
+      WHERE id = $1::uuid
+        AND information_status <> 'INACTIVE'
+    `, [assetId])) as Array<{
+      id: string;
+      areaId: string | null;
+      companyId: string | null;
+    }>;
+
+    if (!asset) {
+      throw new NotFoundException({
+        code: 'FIELD_INVENTORY_NOT_FOUND',
+        message: 'Registro de Inventario no encontrado',
+      });
+    }
+    if (asset.areaId !== context.areaId || asset.companyId !== context.companyId) {
+      throw new BadRequestException({
+        code: 'FIELD_INVENTORY_OUTSIDE_CONTEXT',
+        message: 'El registro no pertenece al Área y Operadora de esta inspección',
+      });
+    }
+    return asset;
+  }
+
+  private async isSelected(visitId: string, assetId: string): Promise<boolean> {
+    const rows = await this.dataSource.query(`
+      SELECT 1
+      FROM inspection_visit_assets
+      WHERE visit_id = $1::uuid
+        AND asset_id = $2::uuid
+        AND included = true
+    `, [visitId, assetId]) as unknown[];
+    return rows.length > 0;
+  }
+
+  private async captureStatus(
+    visitId: string,
+    assetId: string,
+  ): Promise<FieldInventoryCaptureStatus> {
+    const [row] = (await this.dataSource.query(`
+      SELECT
+        EXISTS (
+          SELECT 1
+          FROM asset_field_discoveries discovery
+          WHERE discovery.visit_id = $1::uuid
+            AND discovery.asset_id = $2::uuid
+        ) AS "captureRequired",
+        EXISTS (
+          SELECT 1 FROM asset_geometries geometry WHERE geometry.asset_id = $2::uuid
+        ) AS "hasGeometry",
+        EXISTS (
+          SELECT 1
+          FROM asset_field_capture_events event
+          WHERE event.visit_id = $1::uuid
+            AND event.asset_id = $2::uuid
+            AND event.event_type = 'CREATED'
+        ) AS "creationGpsCaptured",
+        (
+          SELECT COUNT(*)::integer
+          FROM asset_field_capture_events event
+          WHERE event.visit_id = $1::uuid
+            AND event.asset_id = $2::uuid
+            AND event.event_type = 'PHOTO'
+        ) AS "fieldPhotoCount",
+        (
+          SELECT JSONB_BUILD_OBJECT(
+            'latitude', event.device_latitude,
+            'longitude', event.device_longitude,
+            'accuracyM', event.device_accuracy_m,
+            'capturedAt', event.device_captured_at,
+            'deviceLabel', event.device_label
+          )
+          FROM asset_field_capture_events event
+          WHERE event.visit_id = $1::uuid
+            AND event.asset_id = $2::uuid
+          ORDER BY event.device_captured_at DESC, event.created_at DESC, event.id DESC
+          LIMIT 1
+        ) AS "latestDeviceCapture",
+        (
+          SELECT JSONB_BUILD_OBJECT(
+            'latitude', event.exif_latitude,
+            'longitude', event.exif_longitude,
+            'capturedAt', event.exif_captured_at
+          )
+          FROM asset_field_capture_events event
+          WHERE event.visit_id = $1::uuid
+            AND event.asset_id = $2::uuid
+            AND event.event_type = 'PHOTO'
+          ORDER BY event.device_captured_at DESC, event.created_at DESC, event.id DESC
+          LIMIT 1
+        ) AS "latestPhotoExif"
+    `, [visitId, assetId])) as Array<{
+      captureRequired: boolean;
+      hasGeometry: boolean;
+      creationGpsCaptured: boolean;
+      fieldPhotoCount: number;
+      latestDeviceCapture: FieldInventoryCaptureStatus['latestDeviceCapture'];
+      latestPhotoExif: FieldInventoryCaptureStatus['latestPhotoExif'];
+    }>;
+
+    const captureRequired = Boolean(row?.captureRequired);
+    const hasGeometry = Boolean(row?.hasGeometry);
+    const creationGpsCaptured = Boolean(row?.creationGpsCaptured);
+    const fieldPhotoCount = Number(row?.fieldPhotoCount ?? 0);
+
+    return {
+      captureRequired,
+      hasGeometry,
+      creationGpsCaptured,
+      fieldPhotoCount,
+      readyForFinding: !captureRequired || (
+        hasGeometry && creationGpsCaptured && fieldPhotoCount > 0
+      ),
+      latestDeviceCapture: row?.latestDeviceCapture ?? null,
+      latestPhotoExif: row?.latestPhotoExif ?? null,
+    };
+  }
+
+  private async nextFieldCode(observedAt: Date): Promise<string> {
+    const year = observedAt.getUTCFullYear();
+    if (!Number.isInteger(year) || year < 2000 || year > 9999) {
+      throw new BadRequestException({
+        code: 'FIELD_INVENTORY_INVALID_CAPTURE_DATE',
+        message: 'La fecha de captura no es válida para generar el código',
+      });
+    }
+
+    const [row] = (await this.dataSource.query(`
+      INSERT INTO field_inventory_code_sequences (year, last_value)
+      VALUES ($1, 1)
+      ON CONFLICT (year)
+      DO UPDATE SET last_value = field_inventory_code_sequences.last_value + 1
+      RETURNING last_value AS value
+    `, [year])) as Array<{ value: number }>;
+
+    const value = Number(row?.value ?? 0);
+    if (!value) throw new Error('No se pudo generar el código de Inventario de campo');
+    return `CAM-${year}-${String(value).padStart(6, '0')}`;
+  }
+}

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

@@ -1,11 +1,14 @@
 import { Module } from '@nestjs/common';
+import { AssetMasterModule } from '../asset-master/asset-master.module';
 import { AuditModule } from '../audit/audit.module';
+import { FieldInventoryController } from './field-inventory.controller';
+import { FieldInventoryService } from './field-inventory.service';
 import { InspectionVisitsController } from './inspection-visits.controller';
 import { InspectionVisitsService } from './inspection-visits.service';
 
 @Module({
-  imports: [AuditModule],
-  controllers: [InspectionVisitsController],
-  providers: [InspectionVisitsService],
+  imports: [AuditModule, AssetMasterModule],
+  controllers: [InspectionVisitsController, FieldInventoryController],
+  providers: [InspectionVisitsService, FieldInventoryService],
 })
 export class InspectionVisitsModule {}

api-v3/src/version.ts

@@ -1,2 +1,2 @@
-export const API_VERSION = '0.20.0-3';
-export const API_PHASE = 'F1.3';
+export const API_VERSION = '0.21.0-1';
+export const API_PHASE = 'F2.1';

api-v3/test/unit/field-inventory-f2-1.test.ts

@@ -0,0 +1,67 @@
+import 'reflect-metadata';
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { validate } from 'class-validator';
+import { plainToInstance } from 'class-transformer';
+import { FieldInventoryController } from '../../src/inspection-visits/field-inventory.controller';
+import { CreateFieldInventoryDto } from '../../src/inspection-visits/dto/create-field-inventory.dto';
+import { UploadFieldInventoryPhotoDto } from '../../src/inspection-visits/dto/upload-field-inventory-photo.dto';
+import { REQUIRED_PERMISSIONS_KEY } from '../../src/authorization/decorators/require-permissions.decorator';
+
+function permissions(method: string): string[] {
+  const controller = FieldInventoryController.prototype;
+  const handler = controller[method as keyof typeof controller];
+  return Reflect.getMetadata(REQUIRED_PERMISSIONS_KEY, handler) as string[];
+}
+
+test('F2.1 mantiene Inventario de campo bajo política móvil y permisos explícitos', () => {
+  assert.deepEqual(permissions('list'), ['assets.read', 'inspections.execute']);
+  assert.deepEqual(permissions('types'), ['assets.read', 'inspections.execute']);
+  assert.deepEqual(permissions('selectExisting'), ['assets.read', 'inspections.execute']);
+  assert.deepEqual(permissions('create'), ['assets.create', 'inspections.execute']);
+  assert.deepEqual(permissions('uploadPhoto'), ['assets.create', 'inspections.execute']);
+});
+
+test('F2.1 exige GPS del dispositivo al crear Inventario en campo', async () => {
+  const dto = plainToInstance(CreateFieldInventoryDto, {
+    typeId: '11111111-1111-4111-8111-111111111111',
+    name: 'Batería 28',
+    attributes: {},
+    deviceCapturedAt: '2026-09-05T17:30:00-03:00',
+  });
+  const errors = await validate(dto);
+  const properties = new Set(errors.map((error) => error.property));
+  assert.equal(properties.has('deviceLatitude'), true);
+  assert.equal(properties.has('deviceLongitude'), true);
+});
+
+test('F2.1 exige GPS del dispositivo en cada fotografía de campo', async () => {
+  const dto = plainToInstance(UploadFieldInventoryPhotoDto, {
+    deviceCapturedAt: '2026-09-05T17:30:00-03:00',
+  });
+  const errors = await validate(dto);
+  const properties = new Set(errors.map((error) => error.property));
+  assert.equal(properties.has('deviceLatitude'), true);
+  assert.equal(properties.has('deviceLongitude'), true);
+});
+
+test('F2.1 deriva Área y Operadora desde la Inspección y usa el asset anidado del alta provisional', () => {
+  const source = readFileSync('src/inspection-visits/field-inventory.service.ts', 'utf8');
+  assert.match(source, /visit\.operational_area_id AS \"areaId\"/);
+  assert.match(source, /visit\.operator_company_id AS \"companyId\"/);
+  assert.match(source, /operationalAreaId: context\.areaId/);
+  assert.match(source, /operatorCompanyId: context\.companyId/);
+  assert.match(source, /const assetId = discovery\.asset\?\.id/);
+});
+
+test('F2.1 bloquea hallazgos sobre altas de campo hasta tener GPS y foto', () => {
+  const migration = readFileSync(
+    'src/database/migrations/1789668000000-phase-f2-1-field-inventory.ts',
+    'utf8',
+  );
+  assert.match(migration, /enforce_field_inventory_capture_before_finding/);
+  assert.match(migration, /FIELD_INVENTORY_GPS_REQUIRED/);
+  assert.match(migration, /FIELD_INVENTORY_PHOTO_REQUIRED/);
+  assert.match(migration, /REVOKE UPDATE, DELETE ON TABLE asset_field_capture_events/);
+});

scripts/deploy-github.sh

@@ -3,301 +3,112 @@ set -Eeuo pipefail
 
 APP="/var/www/dhv2.korexlabs.com"
 KEY="/root/.ssh/dhv2_github"
-BACKUP_ROOT="/root/DH_V2_BACKUPS"
 DEPLOY_REF="${DHV2_DEPLOY_REF:-deploy}"
-STAMP="$(date +%Y%m%d_%H%M%S)"
-BACKUP="$BACKUP_ROOT/GITHUB_DEPLOY_${STAMP}"
-STAGE="/root/dhv2-github-stage-${STAMP}"
-LOG="/tmp/dhv2-github-deploy-${STAMP}.log"
-API_TEST_IMAGE="dhv2-api:github-${STAMP}"
-WEB_TEST_IMAGE="dhv2-web:github-${STAMP}"
-PHASE="bootstrap"
-PREV_SHA=""
-TARGET_SHA=""
-EXPECTED_API_VERSION=""
-EXPECTED_WEB_VERSION=""
-APP_TOUCHED=0
+LOG="$(mktemp /tmp/dhv2-android-discovery.XXXXXX.log)"
+STATUS="$(mktemp /tmp/dhv2-android-discovery-status.XXXXXX)"
 
 cd "$APP"
 export GIT_SSH_COMMAND="ssh -i $KEY -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new"
 exec > >(tee -a "$LOG") 2>&1
 
-cleanup() {
-  set +e
-  git worktree remove --force "$STAGE" >/dev/null 2>&1 || true
-  rm -rf "$STAGE"
-  docker image rm "$API_TEST_IMAGE" "$WEB_TEST_IMAGE" >/dev/null 2>&1 || true
-}
-
 publish_status() {
   local rc="${1:-1}"
   set +e
-
   local outcome="failure"
   [ "$rc" -eq 0 ] && outcome="success"
-  local current="unknown"
+  local current target status_blob log_blob tree commit
   current="$(git rev-parse HEAD 2>/dev/null || echo unknown)"
-  local status_file log_file status_blob log_blob tree commit
-
-  status_file="$(mktemp /tmp/dhv2-status.XXXXXX)"
-  log_file="$(mktemp /tmp/dhv2-log.XXXXXX)"
-
+  target="$(git rev-parse origin/$DEPLOY_REF 2>/dev/null || echo unknown)"
   {
     echo "status=$outcome"
     echo "exit_code=$rc"
-    echo "phase=$PHASE"
+    echo "phase=android-source-discovery"
     echo "timestamp=$(date --iso-8601=seconds)"
     echo "deploy_ref=$DEPLOY_REF"
-    echo "previous_sha=${PREV_SHA:-unknown}"
-    echo "target_sha=${TARGET_SHA:-unknown}"
+    echo "target_sha=$target"
     echo "current_sha=$current"
-    echo "api_version=${EXPECTED_API_VERSION:-unknown}"
-    echo "web_version=${EXPECTED_WEB_VERSION:-unknown}"
-    echo "app_touched=$APP_TOUCHED"
-    echo "backup=${BACKUP:-unknown}"
-  } > "$status_file"
-
-  tail -n 500 "$LOG" > "$log_file" 2>/dev/null || true
-  status_blob="$(git hash-object -w "$status_file" 2>/dev/null || true)"
-  log_blob="$(git hash-object -w "$log_file" 2>/dev/null || true)"
-
+    echo "app_touched=0"
+    echo "backup=not-required-read-only"
+  } > "$STATUS"
+  status_blob="$(git hash-object -w "$STATUS" 2>/dev/null || true)"
+  log_blob="$(git hash-object -w "$LOG" 2>/dev/null || true)"
   if [ -n "$status_blob" ] && [ -n "$log_blob" ]; then
     tree="$(printf '100644 blob %s\tdeploy.log\n100644 blob %s\tstatus.txt\n' "$log_blob" "$status_blob" | git mktree 2>/dev/null || true)"
     if [ -n "$tree" ]; then
-      commit="$(printf 'deploy-status: %s · phase %s\n' "$outcome" "$PHASE" | git -c user.name='DH V2 Deploy Bot' -c user.email='deploy@dhv2.local' commit-tree "$tree" 2>/dev/null || true)"
+      commit="$(printf 'deploy-status: %s · android-source-discovery\n' "$outcome" | git -c user.name='DH V2 Deploy Bot' -c user.email='deploy@dhv2.local' commit-tree "$tree" 2>/dev/null || true)"
       [ -z "$commit" ] || git push --force origin "$commit:refs/heads/deploy-status" >/dev/null 2>&1 || true
     fi
   fi
-
-  rm -f "$status_file" "$log_file"
+  rm -f "$STATUS" "$LOG"
 }
+trap 'rc=$?; trap - EXIT; publish_status "$rc"; exit "$rc"' EXIT
 
-on_exit() {
-  local rc=$?
-  trap - EXIT ERR
-  cleanup
-  publish_status "$rc"
-  exit "$rc"
-}
-trap on_exit EXIT
-
-rollback() {
-  local rc=$?
-  trap - ERR
-  PHASE="rollback"
-
-  echo
-  echo "============================================================"
-  echo " DH V2 · DEPLOY FALLÓ · ROLLBACK"
-  echo "============================================================"
-
-  cd "$APP"
-  if [ "$APP_TOUCHED" -eq 1 ] && [ -n "${PREV_SHA:-}" ]; then
-    echo "Restaurando aplicación al commit previo: $PREV_SHA"
-    git reset --hard "$PREV_SHA" || true
-    docker compose build api web </dev/null || true
-    docker compose up -d --no-deps --force-recreate api web </dev/null || true
-  else
-    echo "El candidato falló antes de modificar producción; no se reconstruye ni reinicia la aplicación activa."
-  fi
-
-  echo
-  echo "Estado actual:"
-  docker compose ps -a </dev/null || true
-
-  if [ "$APP_TOUCHED" -eq 1 ]; then
-    echo
-    echo "Últimos logs:"
-    docker compose logs --tail=160 api web </dev/null || true
-  fi
-
-  echo
-  if [ -d "$BACKUP" ]; then
-    echo "Backup PRE disponible en: $BACKUP"
-    echo "Las migraciones son forward-only; database-before.dump queda disponible para restauración manual si hiciera falta."
-  else
-    echo "No fue necesario crear backup PRE: el fallo ocurrió durante el preflight del candidato, antes de tocar producción."
-  fi
-  exit "$rc"
-}
-trap rollback ERR
-
-echo
 echo "============================================================"
-echo " DH V2 · DEPLOY DESDE GITHUB · $DEPLOY_REF"
+echo " DH V2 · ANDROID SOURCE DISCOVERY · SOLO LECTURA"
 echo "============================================================"
 
-for cmd in git docker curl tar node; do
-  command -v "$cmd" >/dev/null || { echo "ERROR: falta $cmd"; false; }
-done
-[ -f "$KEY" ] || { echo "ERROR: falta deploy key $KEY"; false; }
-[ -d .git ] || { echo "ERROR: $APP no es repositorio Git"; false; }
-[ -f .env ] || { echo "ERROR: falta $APP/.env"; false; }
-
-git config --global --get-all safe.directory 2>/dev/null | grep -Fxq "$APP" || git config --global --add safe.directory "$APP"
-
-if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
-  echo "ERROR: hay cambios locales versionados en producción."
-  git status --short
-  false
-fi
-
-PREV_SHA="$(git rev-parse HEAD)"
-PHASE="fetch"
 git fetch origin "$DEPLOY_REF"
-TARGET_SHA="$(git rev-parse "origin/$DEPLOY_REF")"
-
-echo "Actual:   $PREV_SHA"
-echo "Objetivo: $TARGET_SHA"
-
-if [ "$TARGET_SHA" = "$PREV_SHA" ]; then
-  echo "Producción ya está en el commit autorizado."
-  PHASE="complete"
-  exit 0
-fi
-
-if ! git merge-base --is-ancestor "$PREV_SHA" "$TARGET_SHA"; then
-  echo "ERROR: origin/$DEPLOY_REF no es fast-forward desde producción."
-  false
-fi
-
-PHASE="candidate-preflight"
-rm -rf "$STAGE"
-git worktree add --detach "$STAGE" "$TARGET_SHA" >/dev/null
-
-EXPECTED_API_VERSION="$(node -p "require('$STAGE/api-v3/package.json').version")"
-EXPECTED_WEB_VERSION="$(node -p "require('$STAGE/web-v2/package.json').version")"
-
-echo "API candidata: $EXPECTED_API_VERSION"
-echo "WEB candidata: $EXPECTED_WEB_VERSION"
-
-docker compose --env-file "$APP/.env" -f "$STAGE/docker-compose.yml" config >/dev/null
-
-while IFS= read -r -d '' script; do
-  bash -n "$script"
-done < <(find "$STAGE/scripts" -type f -name '*.sh' -print0)
+TARGET="$(git rev-parse "origin/$DEPLOY_REF")"
+CURRENT="$(git rev-parse HEAD)"
+echo "Current: $CURRENT"
+echo "Target:  $TARGET"
+git merge-base --is-ancestor "$CURRENT" "$TARGET"
 
 echo
-echo "========== TEST API CANDIDATA =========="
-docker build --target builder -t "$API_TEST_IMAGE" "$STAGE/api-v3" </dev/null
-docker run --rm \
-  -v "$STAGE/api-v3/test:/app/test:ro" \
-  -v "$STAGE/api-v3/tsconfig.test.json:/app/tsconfig.test.json:ro" \
-  "$API_TEST_IMAGE" npm test </dev/null
+echo "========== PROYECTOS GRADLE / ANDROID =========="
+for root in /root /var/www /home /tmp; do
+  [ -d "$root" ] || continue
+  find "$root" -maxdepth 9 -type f \
+    \( -name gradlew -o -name settings.gradle -o -name settings.gradle.kts -o -name build.gradle -o -name build.gradle.kts \) \
+    -printf '%TY-%Tm-%Td %TH:%TM  %10s  %p\n' 2>/dev/null || true
+done | sort -r | head -300
 
 echo
-echo "========== BUILD WEB CANDIDATA =========="
-docker build -t "$WEB_TEST_IMAGE" "$STAGE/web-v2" </dev/null
+echo "========== ZIP / APK / AAB RELACIONADOS =========="
+for root in /root /var/www /home /tmp; do
+  [ -d "$root" ] || continue
+  find "$root" -maxdepth 10 -type f \
+    \( -iname '*android*.zip' -o -iname '*inspeccion*.zip' -o -iname '*dh*.apk' -o -iname '*inspeccion*.apk' -o -iname '*.aab' -o -iname '*E1.1*' -o -iname '*E1_1*' -o -iname '*E1.2*' -o -iname '*E1_2*' -o -iname '*F2.2*' -o -iname '*F2_2*' \) \
+    -printf '%TY-%Tm-%Td %TH:%TM  %10s  %p\n' 2>/dev/null || true
+done | sort -r | head -300
 
-PHASE="backup"
 echo
-echo "========== BACKUP PRE =========="
-install -d -m 700 "$BACKUP"
-docker compose exec -T db sh -lc 'pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Fc' </dev/null > "$BACKUP/database-before.dump"
-tar \
-  --exclude='./.git' \
-  --exclude='./.env' \
-  --exclude='*/node_modules' \
-  --exclude='*/dist' \
-  --exclude='*.zip' \
-  --exclude='*.tar.gz' \
-  --exclude='*.tgz' \
-  -czf "$BACKUP/source-before.tar.gz" .
-install -m 600 .env "$BACKUP/.env"
-git rev-parse HEAD > "$BACKUP/previous.sha"
-printf '%s\n' "$TARGET_SHA" > "$BACKUP/target.sha"
-docker compose ps -a > "$BACKUP/docker-before.txt"
-(
-  cd "$BACKUP"
-  sha256sum database-before.dump source-before.tar.gz .env previous.sha target.sha docker-before.txt > SHA256SUMS.txt
-  sha256sum -c SHA256SUMS.txt
-)
-chmod 600 "$BACKUP"/* "$BACKUP/.env" 2>/dev/null || true
-
-PHASE="fast-forward"
-echo
-echo "========== FAST-FORWARD =========="
-git log --oneline --no-decorate "$PREV_SHA..$TARGET_SHA"
-APP_TOUCHED=1
-git merge --ff-only "origin/$DEPLOY_REF"
-
-PHASE="build"
-echo
-echo "========== BUILD PRODUCCIÓN =========="
-docker compose build api migrate web </dev/null
-
-PHASE="migrations"
-echo
-echo "========== MIGRACIONES =========="
-docker compose --profile tools run --rm migrate </dev/null
-docker compose --profile tools run --rm migrate npm run migration:show </dev/null | tee "$BACKUP/migrations.txt"
-grep -Fq 'Pending migrations: no' "$BACKUP/migrations.txt"
-
-PHASE="recreate"
-echo
-echo "========== RECREATE API + WEB =========="
-docker compose up -d --no-deps --force-recreate api web </dev/null
-
-PHASE="health"
-echo
-echo "========== HEALTH =========="
-HEALTH_OK=0
-for _ in $(seq 1 60); do
-  if curl -fsS --max-time 5 http://127.0.0.1:3101/api/v3/health > "$BACKUP/health.json" 2>/dev/null; then
-    if grep -F '"status":"ok"' "$BACKUP/health.json" >/dev/null; then
-      HEALTH_OK=1
-      break
-    fi
+echo "========== VERSIONES ANDROID =========="
+for root in /root /var/www /home /tmp; do
+  [ -d "$root" ] || continue
+  find "$root" -maxdepth 10 -type f \( -name build.gradle -o -name build.gradle.kts \) -print0 2>/dev/null || true
+done | while IFS= read -r -d '' f; do
+  if grep -Eq 'applicationId|versionCode|versionName|namespace' "$f" 2>/dev/null; then
+    echo "----- $f -----"
+    grep -nE 'applicationId|namespace|versionCode|versionName' "$f" 2>/dev/null | head -30 || true
   fi
-  sleep 2
 done
 
-if [ "$HEALTH_OK" -ne 1 ]; then
-  echo "ERROR: API no pasó healthcheck."
-  docker compose logs --tail=180 api
-  false
-fi
-
-cat "$BACKUP/health.json"
 echo
-
-grep -Fq "\"version\":\"$EXPECTED_API_VERSION\"" "$BACKUP/health.json"
-grep -Fq '"database":"ok"' "$BACKUP/health.json"
-
-WEB_CODE="$(curl -sS -o /dev/null -w '%{http_code}' --max-time 10 http://127.0.0.1:8182/)"
-[ "$WEB_CODE" = "200" ] || { echo "ERROR: WEB HTTP $WEB_CODE"; false; }
-
-PHASE="verify"
-echo
-echo "========== VERIFICACIÓN FINAL =========="
-docker compose ps -a | tee "$BACKUP/docker-after.txt"
-if docker compose ps --status running --services | grep -Fxq api && docker compose ps --status running --services | grep -Fxq web && docker compose ps --status running --services | grep -Fxq db; then
-  echo "Servicios críticos: OK"
-else
-  echo "ERROR: falta un servicio crítico en ejecución."
-  false
-fi
-
-PHASE="post-backup"
-docker compose exec -T db sh -lc 'pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Fc' </dev/null > "$BACKUP/database-after.dump"
-git rev-parse HEAD > "$BACKUP/deployed.sha"
-printf 'API=%s\nWEB=%s\n' "$EXPECTED_API_VERSION" "$EXPECTED_WEB_VERSION" > "$BACKUP/deployed-versions.txt"
-(
-  cd "$BACKUP"
-  sha256sum database-after.dump deployed.sha deployed-versions.txt health.json migrations.txt docker-after.txt >> SHA256SUMS.txt
-  sha256sum -c SHA256SUMS.txt
-)
-chmod 600 "$BACKUP"/* "$BACKUP/.env" 2>/dev/null || true
-
-PHASE="complete"
-trap - ERR
+echo "========== GIT REPOS CON GRADLE =========="
+for root in /root /var/www /home /tmp; do
+  [ -d "$root" ] || continue
+  find "$root" -maxdepth 9 -type d -name .git -print 2>/dev/null || true
+done | while read -r gitdir; do
+  dir="${gitdir%/.git}"
+  if find "$dir" -maxdepth 3 \( -name gradlew -o -name settings.gradle -o -name settings.gradle.kts \) -print -quit 2>/dev/null | grep -q .; then
+    echo "----- $dir -----"
+    git -C "$dir" status --short --branch 2>/dev/null || true
+    git -C "$dir" log -8 --oneline 2>/dev/null || true
+  fi
+done
 
 echo
-echo "============================================================"
-echo " DH V2 · DEPLOY OK"
-echo "============================================================"
-echo "Commit: $TARGET_SHA"
-echo "API:    $EXPECTED_API_VERSION"
-echo "WEB:    $EXPECTED_WEB_VERSION"
-echo "Backup: $BACKUP"
-echo "============================================================"
+echo "========== HUELLA KOTLIN / COMPOSE =========="
+for root in /root /var/www /home /tmp; do
+  [ -d "$root" ] || continue
+  find "$root" -maxdepth 10 -type f -name '*.kt' -printf '%h\n' 2>/dev/null || true
+done | grep -Ei 'dh|inspe|android|mobile|app' | sort -u | head -300
+
+echo
+echo "DISCOVERY_OK"
+
+echo
+echo "========== REGISTRAR COMMIT DIAGNÓSTICO =========="
+git merge --ff-only "origin/$DEPLOY_REF"
+echo "Diagnostic commit registrado localmente: $(git rev-parse HEAD)"

web-v2/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhv2-web",
-  "version": "0.20.0-3",
+  "version": "0.20.0-4",
   "private": true,
   "type": "module",
   "engines": {

web-v2/src/config/version.ts

@@ -1,2 +1,2 @@
-export const APP_VERSION = '0.20.0-3';
-export const APP_PHASE = 'Fase F1.3 · Planificación inteligente de pendientes';
+export const APP_VERSION = '0.20.0-4';
+export const APP_PHASE = 'Fase F1.4 · Briefing contextual antes de salir';

web-v2/src/features/inspections/FieldBriefingPanel.tsx

@@ -0,0 +1,97 @@
+import { useEffect, useState } from 'react';
+import { Link } from 'react-router';
+import { Alert, EmptyState, LoadingBlock, errorMessage } from '../../components/Feedback';
+import { Icon } from '../../components/Icon';
+import type { InspectionVisit } from '../../lib/api';
+import { formatDate, formatDateOnly } from '../../lib/format';
+import {
+  getInspectionFieldBriefing,
+  type FieldBriefing,
+  type FieldBriefingActState,
+} from './fieldBriefingApi';
+
+function stateLabel(state: FieldBriefingActState): string {
+  if (state === 'ACT_RESPONSE_OVERDUE') return 'Respuesta del Acta vencida';
+  if (state === 'ACT_RESPONSE_DUE_SOON') return 'Respuesta próxima a vencer';
+  if (state === 'COMPANY_COMMITMENT_OVERDUE') return 'Compromiso de empresa vencido';
+  if (state === 'VERIFICATION_PENDING') return 'Verificación pendiente';
+  if (state === 'RESPONSE_RECEIVED') return 'Respuesta recibida';
+  return 'Esperando respuesta';
+}
+
+function stateClass(state: FieldBriefingActState): string {
+  if (state === 'ACT_RESPONSE_OVERDUE' || state === 'COMPANY_COMMITMENT_OVERDUE') return 'danger';
+  if (state === 'ACT_RESPONSE_DUE_SOON' || state === 'VERIFICATION_PENDING') return 'warning';
+  return 'pending';
+}
+
+export function FieldBriefingPanel({ visit }: { visit: InspectionVisit }) {
+  const [briefing, setBriefing] = useState<FieldBriefing | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState('');
+
+  useEffect(() => {
+    let active = true;
+    setLoading(true);
+    setError('');
+    getInspectionFieldBriefing(visit.id)
+      .then((value) => { if (active) setBriefing(value); })
+      .catch((requestError) => { if (active) setError(errorMessage(requestError)); })
+      .finally(() => { if (active) setLoading(false); });
+    return () => { active = false; };
+  }, [visit.id, visit.updatedAt]);
+
+  return <section className="panel inspection-checklist-panel">
+    <div className="panel-heading">
+      <div>
+        <span className="eyebrow">ANTES DE CONFIRMAR LA SALIDA</span>
+        <h2>Pendientes para revisar en campo</h2>
+        <p className="section-copy">Actas anteriores del mismo Área y Operadora que requieren atención durante esta inspección. El plazo administrativo pertenece al Acta y los hallazgos se mantienen dentro de su expediente de origen.</p>
+      </div>
+      <div className="form-actions">
+        <Link className="button secondary" to="/preparacion-campo"><Icon name="clipboard" />Vista imprimible</Link>
+      </div>
+    </div>
+
+    {error && <Alert>{error}</Alert>}
+    {loading ? <LoadingBlock label="Preparando pendientes de campo…" /> : briefing && <>
+      <div className="inspection-checklist-metrics">
+        <div><strong>{briefing.summary.acts}</strong><span>actas con pendientes</span></div>
+        <div><strong>{briefing.summary.findings}</strong><span>hallazgos a revisar</span></div>
+        <div><strong>{briefing.summary.inventoryItems}</strong><span>registros involucrados</span></div>
+        <div><strong>{briefing.summary.responseOverdue}</strong><span>respuestas vencidas</span></div>
+        <div><strong>{briefing.summary.commitmentOverdue}</strong><span>compromisos vencidos</span></div>
+        <div><strong>{briefing.summary.verificationPending}</strong><span>verificaciones pendientes</span></div>
+      </div>
+
+      <div className="temporal-notice">
+        <Icon name="clipboard" />
+        <p><strong>Contexto de salida:</strong> {briefing.inspection.area?.name ?? 'Área sin definir'} · {briefing.inspection.operatorCompany?.name ?? 'Operadora sin definir'} · {formatDateOnly(briefing.plannedOn)}.</p>
+      </div>
+
+      {briefing.acts.length === 0
+        ? <EmptyState title="Sin pendientes anteriores" text="No hay Actas anteriores con acciones de campo pendientes para este Área y Operadora." />
+        : <div>{briefing.acts.map((act) => <div className="table-panel" key={act.actId}>
+            <div className="table-summary">
+              <div><strong>{act.actCode}</strong><span>{formatDate(act.occurredAt)} · {act.findings.length} hallazgo{act.findings.length === 1 ? '' : 's'}</span></div>
+              <span className={`status-badge ${stateClass(act.adminState)}`}>{stateLabel(act.adminState)}</span>
+            </div>
+            <div className="table-scroll"><table>
+              <thead><tr><th>Hallazgo</th><th>Inventario</th><th>Gravedad</th><th>Control</th><th /></tr></thead>
+              <tbody>{act.findings.map((finding) => <tr key={finding.id}>
+                <td><Link className="history-asset-link" to={`/hallazgos/${finding.id}`}><strong>{finding.title}</strong><small>{finding.code} · {finding.status}</small></Link></td>
+                <td><Link className="history-asset-link" to={`/inventarios/${finding.asset.id}`}><strong>{finding.asset.name}</strong><small>{finding.asset.code} · {finding.asset.typeName}</small></Link></td>
+                <td>{finding.severity ?? '—'}</td>
+                <td>{finding.nextControlOn ? formatDateOnly(finding.nextControlOn) : 'A definir'}</td>
+                <td className="action-cell"><Link className="button secondary compact" to={`/seguimiento-actas/${act.actId}`}>Ver Acta</Link></td>
+              </tr>)}</tbody>
+            </table></div>
+            <div className="table-summary">
+              <span>Plazo empresa: <strong>{act.responseDueOn ? formatDateOnly(act.responseDueOn) : 'sin definir'}</strong></span>
+              <span>Respuesta: <strong>{act.responseReceivedOn ? formatDateOnly(act.responseReceivedOn) : 'pendiente'}</strong></span>
+              <span>Compromiso: <strong>{act.committedCorrectionOn ? formatDateOnly(act.committedCorrectionOn) : '—'}</strong></span>
+            </div>
+          </div>)}</div>}
+    </>}
+  </section>;
+}

web-v2/src/features/inspections/InspectionActsPanel.tsx

@@ -6,6 +6,7 @@ import { Icon } from '../../components/Icon';
 import { listInspectionActs } from '../../lib/api';
 import type { InspectionActListItem, InspectionVisit } from '../../lib/api';
 import { formatDate } from '../../lib/format';
+import { FieldBriefingPanel } from './FieldBriefingPanel';
 import { inspectionActStatusClass, inspectionActStatusLabel } from './inspectionActPresentation';
 
 export function InspectionActsPanel({ visit }: { visit: InspectionVisit }) {
@@ -25,17 +26,18 @@ export function InspectionActsPanel({ visit }: { visit: InspectionVisit }) {
       .finally(() => setLoading(false));
   }, [canRead, visit.id]);
 
-  if (!canRead) return null;
-
-  return <section className="inspection-acts-panel">
-    <div className="panel-heading">
-      <div><span className="eyebrow">ACTAS DE LA INSPECCIÓN</span><h2>Actas generadas</h2><p className="section-copy">Una inspección puede generar múltiples actas. Cada acta agrupa sus propios hallazgos y tendrá un único informe.</p></div>
-      <span className="status-badge pending">Sólo lectura</span>
-    </div>
-    <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Las actas se crean en la APK.</strong> El dashboard permite consultar cada acta, sus hallazgos, firmas e informe después de la sincronización.</p></div>
-    {error && <Alert>{error}</Alert>}
-    {loading ? <LoadingBlock label="Cargando actas…" /> : acts.length === 0
-      ? <EmptyState title="Sin actas sincronizadas" text={visit.status === 'IN_PROGRESS' ? 'El inspector puede crear la primera acta desde la APK.' : 'Aparecerán aquí a medida que el inspector genere actas desde la APK.'} />
-      : <div className="table-panel inspection-acts-table"><div className="table-summary"><strong>Actas de la inspección</strong><span>Numeración oficial global por año</span></div><div className="table-scroll"><table><thead><tr><th>Acta</th><th>Estado</th><th>Fecha</th><th>Registros</th><th>Hallazgos</th><th>Versión</th><th /></tr></thead><tbody>{acts.map((act) => <tr key={act.id}><td><div className="asset-cell"><span className="asset-symbol"><Icon name="clipboard" size={17} /></span><div><strong>{act.title}</strong><small>{act.code}</small></div></div></td><td><span className={`status-badge ${inspectionActStatusClass(act.status)}`}>{inspectionActStatusLabel(act.status)}</span></td><td>{formatDate(act.occurredAt)}</td><td>{act.assetCount}</td><td>{act.findingCount}</td><td>v{act.currentVersion}</td><td className="action-cell"><Link className="icon-button" to={`/inspecciones/actas/${act.id}`} aria-label={`Abrir ${act.code}`}><Icon name="chevron" /></Link></td></tr>)}</tbody></table></div></div>}
-  </section>;
+  return <>
+    <FieldBriefingPanel visit={visit} />
+    {canRead && <section className="inspection-acts-panel">
+      <div className="panel-heading">
+        <div><span className="eyebrow">ACTAS DE LA INSPECCIÓN</span><h2>Actas generadas</h2><p className="section-copy">Una inspección puede generar múltiples actas. Cada acta agrupa sus propios hallazgos y tendrá un único informe.</p></div>
+        <span className="status-badge pending">Sólo lectura</span>
+      </div>
+      <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Las actas se crean en la APK.</strong> El dashboard permite consultar cada acta, sus hallazgos, firmas e informe después de la sincronización.</p></div>
+      {error && <Alert>{error}</Alert>}
+      {loading ? <LoadingBlock label="Cargando actas…" /> : acts.length === 0
+        ? <EmptyState title="Sin actas sincronizadas" text={visit.status === 'IN_PROGRESS' ? 'El inspector puede crear la primera acta desde la APK.' : 'Aparecerán aquí a medida que el inspector genere actas desde la APK.'} />
+        : <div className="table-panel inspection-acts-table"><div className="table-summary"><strong>Actas de la inspección</strong><span>Numeración oficial global por año</span></div><div className="table-scroll"><table><thead><tr><th>Acta</th><th>Estado</th><th>Fecha</th><th>Registros</th><th>Hallazgos</th><th>Versión</th><th /></tr></thead><tbody>{acts.map((act) => <tr key={act.id}><td><div className="asset-cell"><span className="asset-symbol"><Icon name="clipboard" size={17} /></span><div><strong>{act.title}</strong><small>{act.code}</small></div></div></td><td><span className={`status-badge ${inspectionActStatusClass(act.status)}`}>{inspectionActStatusLabel(act.status)}</span></td><td>{formatDate(act.occurredAt)}</td><td>{act.assetCount}</td><td>{act.findingCount}</td><td>v{act.currentVersion}</td><td className="action-cell"><Link className="icon-button" to={`/inspecciones/actas/${act.id}`} aria-label={`Abrir ${act.code}`}><Icon name="chevron" /></Link></td></tr>)}</tbody></table></div></div>}
+    </section>}
+  </>;
 }

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

@@ -0,0 +1,56 @@
+import { apiRequest } from '../../lib/api';
+
+export type FieldBriefingActState =
+  | 'ACT_RESPONSE_OVERDUE'
+  | 'ACT_RESPONSE_DUE_SOON'
+  | 'WAITING_RESPONSE'
+  | 'COMPANY_COMMITMENT_OVERDUE'
+  | 'VERIFICATION_PENDING'
+  | 'RESPONSE_RECEIVED';
+
+export interface FieldBriefingFinding {
+  id: string;
+  code: string;
+  title: string;
+  status: string;
+  severity: number | null;
+  nextControlOn: string | null;
+  asset: { id: string; code: string; name: string; typeName: string };
+}
+
+export interface FieldBriefingAct {
+  actId: string;
+  actCode: string;
+  occurredAt: string;
+  adminState: FieldBriefingActState;
+  responseDueOn: string | null;
+  responseReceivedOn: string | null;
+  committedCorrectionOn: string | null;
+  latestResponseId: string | null;
+  findings: FieldBriefingFinding[];
+}
+
+export interface FieldBriefing {
+  inspection: {
+    id: string;
+    code: string;
+    status: string;
+    plannedStartAt: string | null;
+    area: { id: string; code: string; name: string } | null;
+    operatorCompany: { id: string; code: string; name: string } | null;
+  };
+  plannedOn: string;
+  summary: {
+    acts: number;
+    findings: number;
+    inventoryItems: number;
+    responseOverdue: number;
+    commitmentOverdue: number;
+    verificationPending: number;
+  };
+  acts: FieldBriefingAct[];
+}
+
+export function getInspectionFieldBriefing(visitId: string) {
+  return apiRequest<FieldBriefing>(`/inspection-visits/${visitId}/field-briefing`);
+}