fix(F1.3): asegurar visita única en build estricto

F1.3 · Preparación inteligente de campo
Agrega paquete de campo por inspección con Actas anteriores del mismo contexto, hallazgos abiertos priorizados para verificación y vista web imprimible.
2026-09-05 17:08:27 -03:00 · 2026-09-05 17:05:46 -03:00
27 changed files with 444 additions and 1842 deletions
@@ -1,6 +1,6 @@
 {
  "name": "dhv2-api",
-  "version": "0.21.0-1",
+  "version": "0.20.0-3",
  "private": true,
  "license": "UNLICENSED",
  "scripts": {
@@ -1,22 +1,12 @@
 import { Module } from '@nestjs/common';
 import { AuditModule } from '../audit/audit.module';
-import {
+import { ActAdministrationController, ActAdministrationQueueController, ActCompanyResponseContentController } from './act-administration.controller';
  ActAdministrationController,
  ActAdministrationQueueController,
  ActCompanyResponseContentController,
 } from './act-administration.controller';
 import { ActAdministrationService } from './act-administration.service';
 import { FieldBriefingController } from './field-briefing.controller';
 import { FieldBriefingService } from './field-briefing.service';
@Module({
  imports: [AuditModule],
-  controllers: [
+  controllers: [ActAdministrationQueueController, ActAdministrationController, ActCompanyResponseContentController],
-    ActAdministrationQueueController,
+  providers: [ActAdministrationService],
    ActAdministrationController,
    ActCompanyResponseContentController,
    FieldBriefingController,
  ],
  providers: [ActAdministrationService, FieldBriefingService],
 })
 export class ActAdministrationModule {}
@@ -1,242 +0,0 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { DataSource } from 'typeorm';
 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: Date;
  adminState: FieldBriefingActState;
  responseDueOn: string | null;
  responseReceivedOn: string | null;
  committedCorrectionOn: string | null;
  latestResponseId: string | null;
  findings: FieldBriefingFinding[];
 }
@Injectable()
 export class FieldBriefingService {
  constructor(private readonly dataSource: DataSource) {}
  async forVisit(visitId: string) {
    const [visit] = (await this.dataSource.query(`
      SELECT
        visit.id,
        visit.code,
        visit.status,
        visit.planned_start_at AS "plannedStartAt",
        visit.operational_area_id AS "areaId",
        visit.operator_company_id AS "companyId",
        area.code AS "areaCode",
        area.name AS "areaName",
        company.code AS "companyCode",
        COALESCE(profile.legal_name, company.name) AS "companyName"
      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
      LEFT JOIN organization_profiles profile ON profile.asset_id = company.id
      WHERE visit.id = $1
    `, [visitId])) as Array<Record<string, unknown>>;
    if (!visit) {
      throw new NotFoundException({
        code: 'INSPECTION_VISIT_NOT_FOUND',
        message: 'Inspección no encontrada',
      });
    }
    const plannedOn = String(visit.plannedStartAt ?? new Date().toISOString()).slice(0, 10);
    const rows = (await this.dataSource.query(`
      WITH prior_acts AS (
        SELECT
          act.id AS act_id,
          act.code AS act_code,
          act.occurred_at,
          deadline.response_due_on,
          response.id AS latest_response_id,
          response.received_on AS response_received_on,
          response.committed_correction_on,
          finding.id AS finding_id,
          finding.code AS finding_code,
          finding.title AS finding_title,
          finding.status AS finding_status,
          finding.severity,
          finding.next_control_on,
          asset.id AS asset_id,
          asset.code AS asset_code,
          asset.name AS asset_name,
          asset_type.name AS asset_type_name,
          CASE
            WHEN response.id IS NULL
              AND deadline.response_due_on IS NOT NULL
              AND deadline.response_due_on < $4::date
              THEN 'ACT_RESPONSE_OVERDUE'
            WHEN response.id IS NULL
              AND deadline.response_due_on IS NOT NULL
              AND deadline.response_due_on BETWEEN $4::date AND ($4::date + 3)
              THEN 'ACT_RESPONSE_DUE_SOON'
            WHEN response.id IS NOT NULL
              AND response.committed_correction_on IS NOT NULL
              AND response.committed_correction_on < $4::date
              THEN 'COMPANY_COMMITMENT_OVERDUE'
            WHEN response.id IS NOT NULL
              AND finding.next_control_on IS NULL
              THEN 'VERIFICATION_PENDING'
            WHEN response.id IS NOT NULL
              THEN 'RESPONSE_RECEIVED'
            ELSE 'WAITING_RESPONSE'
          END AS admin_state
        FROM inspection_acts act
        INNER JOIN inspection_visits source_visit ON source_visit.id = act.visit_id
        INNER JOIN inspection_findings finding ON finding.act_id = act.id
          AND finding.status = 'OPEN'
        INNER JOIN assets asset ON asset.id = finding.asset_id
        INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
        LEFT JOIN LATERAL (
          SELECT event.response_due_on
          FROM inspection_act_deadline_events event
          WHERE event.act_id = act.id
          ORDER BY event.created_at DESC, event.id DESC
          LIMIT 1
        ) deadline ON true
        LEFT JOIN LATERAL (
          SELECT company_response.id, company_response.received_on, company_response.committed_correction_on
          FROM inspection_act_company_responses company_response
          WHERE company_response.act_id = act.id
          ORDER BY company_response.received_on DESC, company_response.created_at DESC, company_response.id DESC
          LIMIT 1
        ) response ON true
        WHERE act.status IN ('CLOSED', 'RECTIFIED')
          AND source_visit.id <> $1
          AND source_visit.operational_area_id = $2::uuid
          AND source_visit.operator_company_id = $3::uuid
      )
      SELECT *
      FROM prior_acts
      WHERE admin_state IN (
        'ACT_RESPONSE_OVERDUE',
        'ACT_RESPONSE_DUE_SOON',
        'COMPANY_COMMITMENT_OVERDUE',
        'VERIFICATION_PENDING',
        'RESPONSE_RECEIVED'
      )
         OR next_control_on IS NOT NULL
      ORDER BY
        CASE admin_state
          WHEN 'ACT_RESPONSE_OVERDUE' THEN 1
          WHEN 'COMPANY_COMMITMENT_OVERDUE' THEN 2
          WHEN 'VERIFICATION_PENDING' THEN 3
          WHEN 'ACT_RESPONSE_DUE_SOON' THEN 4
          ELSE 5
        END,
        response_due_on NULLS LAST,
        occurred_at,
        act_code,
        finding_code
    `, [visitId, visit.areaId, visit.companyId, plannedOn])) as Array<{
      act_id: string;
      act_code: string;
      occurred_at: Date;
      response_due_on: string | null;
      latest_response_id: string | null;
      response_received_on: string | null;
      committed_correction_on: string | null;
      finding_id: string;
      finding_code: string;
      finding_title: string;
      finding_status: string;
      severity: number | null;
      next_control_on: string | null;
      asset_id: string;
      asset_code: string;
      asset_name: string;
      asset_type_name: string;
      admin_state: FieldBriefingActState;
    }>;
    const byAct = new Map<string, FieldBriefingAct>();
    for (const row of rows) {
      let act = byAct.get(row.act_id);
      if (!act) {
        act = {
          actId: row.act_id,
          actCode: row.act_code,
          occurredAt: row.occurred_at,
          adminState: row.admin_state,
          responseDueOn: row.response_due_on,
          responseReceivedOn: row.response_received_on,
          committedCorrectionOn: row.committed_correction_on,
          latestResponseId: row.latest_response_id,
          findings: [],
        };
        byAct.set(row.act_id, act);
      }
      act.findings.push({
        id: row.finding_id,
        code: row.finding_code,
        title: row.finding_title,
        status: row.finding_status,
        severity: row.severity,
        nextControlOn: row.next_control_on,
        asset: {
          id: row.asset_id,
          code: row.asset_code,
          name: row.asset_name,
          typeName: row.asset_type_name,
        },
      });
    }
    const acts = [...byAct.values()];
    const assetIds = new Set<string>();
    let findingCount = 0;
    for (const act of acts) {
      findingCount += act.findings.length;
      for (const finding of act.findings) assetIds.add(finding.asset.id);
    }
    return {
      inspection: {
        id: visit.id,
        code: visit.code,
        status: visit.status,
        plannedStartAt: visit.plannedStartAt,
        area: visit.areaId ? { id: visit.areaId, code: visit.areaCode, name: visit.areaName } : null,
        operatorCompany: visit.companyId ? { id: visit.companyId, code: visit.companyCode, name: visit.companyName } : null,
      },
      plannedOn,
      summary: {
        acts: acts.length,
        findings: findingCount,
        inventoryItems: assetIds.size,
        responseOverdue: acts.filter((item) => item.adminState === 'ACT_RESPONSE_OVERDUE').length,
        commitmentOverdue: acts.filter((item) => item.adminState === 'COMPANY_COMMITMENT_OVERDUE').length,
        verificationPending: acts.filter((item) => item.adminState === 'VERIFICATION_PENDING').length,
      },
      acts,
    };
  }
 }
@@ -25,6 +25,7 @@ import { AssetImportsModule } from './asset-imports/asset-imports.module';
 import { InspectionReportsModule } from './inspection-reports/inspection-reports.module';
 import { InspectionVerificationsModule } from './inspection-verifications/inspection-verifications.module';
 import { ActAdministrationModule } from './act-administration/act-administration.module';
 import { FieldBriefingModule } from './field-briefing/field-briefing.module';
 function required(config: ConfigService, key: string): string {
  const value = config.get<string>(key);
@@ -78,6 +79,7 @@ function required(config: ConfigService, key: string): string {
    InspectionReportsModule,
    InspectionVerificationsModule,
    ActAdministrationModule,
    FieldBriefingModule,
    AssetImportsModule,
  ],
  controllers: [HealthController],
@@ -49,12 +49,6 @@ import { FieldDiscoveryInspectionLinkService } from '../inspection-operations/fi
    AssetRegistryService,
    FieldDiscoveryInspectionLinkService,
  ],
-  exports: [
+  exports: [AssetHistoryService],
    AssetHistoryService,
    AssetsService,
    AssetGeometriesService,
    AssetMediaService,
    FieldDiscoveryInspectionLinkService,
  ],
 })
 export class AssetMasterModule {}
@@ -1,197 +0,0 @@
 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`);
  }
 }
@@ -9,6 +9,6 @@ export class FieldBriefingController {
  @Get()
  @RequirePermissions('inspections.read')
  get(@Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string) {
-    return this.briefing.forVisit(visitId);
+    return this.briefing.getForVisit(visitId);
  }
 }
@@ -0,0 +1,9 @@
 import { Module } from '@nestjs/common';
 import { FieldBriefingController } from './field-briefing.controller';
 import { FieldBriefingService } from './field-briefing.service';
@Module({
  controllers: [FieldBriefingController],
  providers: [FieldBriefingService],
 })
 export class FieldBriefingModule {}
@@ -0,0 +1,310 @@
 import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
 import { DataSource } from 'typeorm';
 export type FieldBriefingAdminState =
  | 'NEW'
  | 'WAITING_RESPONSE'
  | 'DUE_SOON'
  | 'OVERDUE'
  | 'RESPONSE_RECEIVED'
  | 'VERIFICATION_PENDING'
  | 'COMMITMENT_OVERDUE';
 export type FieldBriefingReviewState = 'REQUIRED' | 'UPCOMING' | 'CONTEXT';
 interface BriefingVisitRow {
  id: string;
  code: string;
  status: string;
  plannedStartAt: Date | null;
  areaId: string | null;
  areaCode: string | null;
  areaName: string | null;
  companyId: string | null;
  companyCode: string | null;
  companyName: string | null;
 }
 interface BriefingFindingRow {
  sourceActId: string;
  sourceActCode: string;
  sourceActOccurredAt: Date;
  sourceVisitId: string;
  sourceVisitCode: string;
  responseDueOn: string | null;
  responseReceivedOn: string | null;
  committedCorrectionOn: string | null;
  latestResponseId: string | null;
  responseHasPdf: boolean;
  adminState: FieldBriefingAdminState;
  reviewState: FieldBriefingReviewState;
  reviewReason: string;
  priority: number;
  findingId: string;
  findingCode: string;
  findingTitle: string;
  severity: number | null;
  nextControlOn: string | null;
  latestVerificationOutcome: string | null;
  assetId: string;
  assetCode: string;
  assetName: string;
  assetTypeName: string;
 }
@Injectable()
 export class FieldBriefingService {
  constructor(private readonly dataSource: DataSource) {}
  async getForVisit(visitId: string) {
    const [visit] = (await this.dataSource.query(`
      SELECT
        visit.id,
        visit.code,
        visit.status,
        visit.planned_start_at AS "plannedStartAt",
        visit.operational_area_id AS "areaId",
        area.code AS "areaCode",
        area.name AS "areaName",
        visit.operator_company_id AS "companyId",
        company.code AS "companyCode",
        COALESCE(profile.legal_name, company.name) AS "companyName"
      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
      LEFT JOIN organization_profiles profile ON profile.asset_id = company.id
      WHERE visit.id = $1
    `, [visitId])) as BriefingVisitRow[];
    if (!visit) {
      throw new NotFoundException({
        code: 'INSPECTION_VISIT_NOT_FOUND',
        message: 'Inspección no encontrada',
      });
    }
    if (!visit.areaId || !visit.companyId) {
      throw new BadRequestException({
        code: 'FIELD_BRIEFING_CONTEXT_REQUIRED',
        message: 'La inspección debe tener Área y Operadora antes de preparar el paquete de campo',
      });
    }
    const referenceAt = visit.plannedStartAt ?? new Date();
    const referenceDate = referenceAt.toISOString().slice(0, 10);
    const rows = (await this.dataSource.query(`
      SELECT
        act.id AS "sourceActId",
        act.code AS "sourceActCode",
        act.occurred_at AS "sourceActOccurredAt",
        source_visit.id AS "sourceVisitId",
        source_visit.code AS "sourceVisitCode",
        deadline.response_due_on AS "responseDueOn",
        response.received_on AS "responseReceivedOn",
        response.committed_correction_on AS "committedCorrectionOn",
        response.id AS "latestResponseId",
        (response.stored_name IS NOT NULL) AS "responseHasPdf",
        CASE
          WHEN response.id IS NOT NULL
            AND response.committed_correction_on IS NOT NULL
            AND response.committed_correction_on < $5::date
            THEN 'COMMITMENT_OVERDUE'
          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL
            THEN 'VERIFICATION_PENDING'
          WHEN response.id IS NOT NULL THEN 'RESPONSE_RECEIVED'
          WHEN deadline.id IS NULL THEN 'NEW'
          WHEN deadline.response_due_on < $5::date THEN 'OVERDUE'
          WHEN deadline.response_due_on <= ($5::date + 3) THEN 'DUE_SOON'
          ELSE 'WAITING_RESPONSE'
        END AS "adminState",
        CASE
          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
            AND finding.next_control_on IS NOT NULL
            AND finding.next_control_on <= $5::date
            THEN 'REQUIRED'
          WHEN response.id IS NOT NULL
            AND response.committed_correction_on IS NOT NULL
            AND response.committed_correction_on <= $5::date
            THEN 'REQUIRED'
          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL
            THEN 'REQUIRED'
          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
            AND finding.next_control_on IS NOT NULL
            AND finding.next_control_on <= ($5::date + 30)
            THEN 'UPCOMING'
          ELSE 'CONTEXT'
        END AS "reviewState",
        CASE
          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
            AND finding.next_control_on IS NOT NULL
            AND finding.next_control_on <= $5::date
            THEN 'CONTROL_OVERDUE'
          WHEN response.id IS NOT NULL
            AND response.committed_correction_on IS NOT NULL
            AND response.committed_correction_on <= $5::date
            THEN 'COMMITMENT_REACHED'
          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL
            THEN 'RESPONSE_WITHOUT_CONTROL'
          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
            AND finding.next_control_on IS NOT NULL
            AND finding.next_control_on <= ($5::date + 30)
            THEN 'CONTROL_UPCOMING'
          WHEN response.id IS NULL
            AND deadline.response_due_on IS NOT NULL
            AND deadline.response_due_on < $5::date
            THEN 'ADMIN_RESPONSE_OVERDUE'
          ELSE 'CONTEXT_ONLY'
        END AS "reviewReason",
        CASE
          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
            AND finding.next_control_on IS NOT NULL
            AND finding.next_control_on <= $5::date THEN 1
          WHEN response.id IS NOT NULL
            AND response.committed_correction_on IS NOT NULL
            AND response.committed_correction_on <= $5::date THEN 2
          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL THEN 3
          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
            AND finding.next_control_on IS NOT NULL
            AND finding.next_control_on <= ($5::date + 30) THEN 4
          WHEN response.id IS NULL
            AND deadline.response_due_on IS NOT NULL
            AND deadline.response_due_on < $5::date THEN 5
          ELSE 6
        END AS priority,
        finding.id AS "findingId",
        finding.code AS "findingCode",
        finding.title AS "findingTitle",
        finding.severity,
        finding.next_control_on AS "nextControlOn",
        verification.outcome AS "latestVerificationOutcome",
        asset.id AS "assetId",
        asset.code AS "assetCode",
        asset.name AS "assetName",
        asset_type.name AS "assetTypeName"
      FROM inspection_acts act
      INNER JOIN inspection_visits source_visit ON source_visit.id = act.visit_id
      INNER JOIN inspection_findings finding ON finding.act_id = act.id
      INNER JOIN assets asset ON asset.id = finding.asset_id
      INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
      LEFT JOIN LATERAL (
        SELECT event.id, event.response_due_on
        FROM inspection_act_deadline_events event
        WHERE event.act_id = act.id
        ORDER BY event.created_at DESC, event.id DESC
        LIMIT 1
      ) deadline ON true
      LEFT JOIN LATERAL (
        SELECT company_response.id, company_response.received_on,
               company_response.committed_correction_on, company_response.stored_name
        FROM inspection_act_company_responses company_response
        WHERE company_response.act_id = act.id
        ORDER BY company_response.received_on DESC,
                 company_response.created_at DESC,
                 company_response.id DESC
        LIMIT 1
      ) response ON true
      LEFT JOIN LATERAL (
        SELECT verification_visit.outcome
        FROM inspection_finding_verification_visits verification_visit
        WHERE verification_visit.finding_id = finding.id
          AND verification_visit.outcome IS NOT NULL
        ORDER BY verification_visit.result_recorded_at DESC NULLS LAST,
                 verification_visit.created_at DESC,
                 verification_visit.id DESC
        LIMIT 1
      ) verification ON true
      WHERE source_visit.operational_area_id = $2
        AND source_visit.operator_company_id = $3
        AND source_visit.id <> $1
        AND act.status IN ('CLOSED', 'RECTIFIED')
        AND finding.status = 'OPEN'
        AND COALESCE(act.closed_at, act.occurred_at) <= $4::timestamptz
      ORDER BY priority, act.occurred_at, act.act_number, finding.finding_number
    `, [visit.id, visit.areaId, visit.companyId, referenceAt.toISOString(), referenceDate])) as BriefingFindingRow[];
    const actMap = new Map<string, {
      actId: string;
      actCode: string;
      occurredAt: Date;
      sourceVisit: { id: string; code: string };
      adminState: FieldBriefingAdminState;
      responseDueOn: string | null;
      latestResponse: null | {
        id: string;
        receivedOn: string;
        committedCorrectionOn: string | null;
        hasPdf: boolean;
      };
      findings: Array<Record<string, unknown>>;
    }>();
    for (const row of rows) {
      let act = actMap.get(row.sourceActId);
      if (!act) {
        act = {
          actId: row.sourceActId,
          actCode: row.sourceActCode,
          occurredAt: row.sourceActOccurredAt,
          sourceVisit: { id: row.sourceVisitId, code: row.sourceVisitCode },
          adminState: row.adminState,
          responseDueOn: row.responseDueOn,
          latestResponse: row.latestResponseId && row.responseReceivedOn ? {
            id: row.latestResponseId,
            receivedOn: row.responseReceivedOn,
            committedCorrectionOn: row.committedCorrectionOn,
            hasPdf: Boolean(row.responseHasPdf),
          } : null,
          findings: [],
        };
        actMap.set(row.sourceActId, act);
      }
      act.findings.push({
        id: row.findingId,
        code: row.findingCode,
        title: row.findingTitle,
        severity: row.severity,
        nextControlOn: row.nextControlOn,
        latestVerificationOutcome: row.latestVerificationOutcome,
        reviewState: row.reviewState,
        reviewReason: row.reviewReason,
        priority: Number(row.priority),
        asset: {
          id: row.assetId,
          code: row.assetCode,
          name: row.assetName,
          typeName: row.assetTypeName,
        },
      });
    }
    const acts = Array.from(actMap.values());
    const uniqueAssets = new Set(rows.map((row) => row.assetId));
    const required = rows.filter((row) => row.reviewState === 'REQUIRED').length;
    const upcoming = rows.filter((row) => row.reviewState === 'UPCOMING').length;
    const adminAttention = rows.filter((row) =>
      ['OVERDUE', 'DUE_SOON', 'COMMITMENT_OVERDUE'].includes(row.adminState),
    ).length;
    return {
      visit: {
        id: visit.id,
        code: visit.code,
        status: visit.status,
        plannedStartAt: visit.plannedStartAt,
        operationalArea: { id: visit.areaId, code: visit.areaCode, name: visit.areaName },
        operatorCompany: { id: visit.companyId, code: visit.companyCode, name: visit.companyName },
      },
      referenceDate,
      generatedAt: new Date().toISOString(),
      summary: {
        actCount: acts.length,
        openFindingCount: rows.length,
        fieldReviewRequired: required,
        fieldReviewUpcoming: upcoming,
        administrativeAttention: adminAttention,
        assetCount: uniqueAssets.size,
      },
      acts,
    };
  }
 }
@@ -26,60 +26,19 @@ 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 (
+        INSERT INTO inspection_visit_assets (visit_id, asset_id, included, added_by)
-          visit_id, asset_id, included, planning_source, added_by,
+        VALUES ($1, $2, true, $3)
          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(
        `
@@ -1,85 +0,0 @@
 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;
 }
@@ -1,25 +0,0 @@
 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;
 }
@@ -1,70 +0,0 @@
 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;
 }
@@ -1,93 +0,0 @@
 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);
  }
 }
@@ -1,648 +0,0 @@
 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')}`;
  }
 }
@@ -1,14 +1,11 @@
 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, AssetMasterModule],
+  imports: [AuditModule],
-  controllers: [InspectionVisitsController, FieldInventoryController],
+  controllers: [InspectionVisitsController],
-  providers: [InspectionVisitsService, FieldInventoryService],
+  providers: [InspectionVisitsService],
 })
 export class InspectionVisitsModule {}
@@ -1,2 +1,2 @@
-export const API_VERSION = '0.21.0-1';
+export const API_VERSION = '0.20.0-3';
-export const API_PHASE = 'F2.1';
+export const API_PHASE = 'F1.3';
@@ -1,67 +0,0 @@
 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/);
 });
@@ -1,30 +1,37 @@
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
-import { test } from 'node:test';
+import { resolve } from 'node:path';
 import test from 'node:test';
-const service = readFileSync('src/act-administration/field-briefing.service.ts', 'utf8');
+const source = (path: string) => readFileSync(resolve(process.cwd(), path), 'utf8');
-const controller = readFileSync('src/act-administration/field-briefing.controller.ts', 'utf8');
+const service = source('src/field-briefing/field-briefing.service.ts');
-const moduleSource = readFileSync('src/act-administration/act-administration.module.ts', 'utf8');
+const controller = source('src/field-briefing/field-briefing.controller.ts');
-test('F1.3 agrupa pendientes de campo por Acta y Hallazgo', () => {
+test('F1.3 prepares field briefing from prior Acts in the same operational context', () => {
  assert.match(service, /source_visit\.operational_area_id = \$2/);
  assert.match(service, /source_visit\.operator_company_id = \$3/);
  assert.match(service, /source_visit\.id <> \$1/);
 });
 test('F1.3 uses Act-level deadline and company response ledgers', () => {
  assert.match(service, /inspection_act_deadline_events/);
  assert.match(service, /inspection_act_company_responses/);
-  assert.match(service, /source_visit\.operational_area_id = \$2::uuid/);
+  assert.doesNotMatch(service, /company_response_received_on/);
  assert.match(service, /source_visit\.operator_company_id = \$3::uuid/);
  assert.match(service, /ACT_RESPONSE_OVERDUE/);
  assert.match(service, /COMPANY_COMMITMENT_OVERDUE/);
  assert.match(service, /VERIFICATION_PENDING/);
  assert.match(service, /findings: \[\]/);
 });
-test('F1.3 expone el briefing para una inspección planificada', () => {
+test('F1.3 only turns open findings from closed Acts into pending field context', () => {
-  assert.match(controller, /inspection-visits\/:visitId\/field-briefing/);
+  assert.match(service, /act\.status IN \('CLOSED', 'RECTIFIED'\)/);
-  assert.match(controller, /RequirePermissions\('inspections\.read'\)/);
+  assert.match(service, /finding\.status = 'OPEN'/);
  assert.match(moduleSource, /FieldBriefingController/);
  assert.match(moduleSource, /FieldBriefingService/);
 });
-test('F1.3 no usa el plazo del Hallazgo como plazo administrativo', () => {
+test('F1.3 separates required field review, upcoming review and administrative context', () => {
-  assert.doesNotMatch(service, /correction_due_on/);
+  assert.match(service, /'REQUIRED'/);
-  assert.match(service, /deadline\.response_due_on/);
+  assert.match(service, /'UPCOMING'/);
  assert.match(service, /'CONTEXT'/);
  assert.match(service, /ADMIN_RESPONSE_OVERDUE/);
 });
 test('F1.3 exposes the briefing through the inspection read contract', () => {
  assert.match(controller, /field-briefing/);
  assert.match(controller, /inspections\.read/);
 });
@@ -1,11 +0,0 @@
 # F1.3 · Planificación inteligente de pendientes
 Objetivo: al planificar una inspección para un Área/Yacimiento + Operadora, generar un paquete de campo con pendientes administrativos y operativos provenientes de Actas anteriores del mismo contexto.
 Reglas:
 - La unidad administrativa es el Acta.
 - Los hallazgos se muestran dentro de su Acta de origen.
 - El checklist de planificación incluye Actas con respuesta vencida o por vencer, respuestas de empresa con fecha comprometida de regularización, y hallazgos con control/verificación pendiente.
 - El inspector puede ver antecedentes antes de salir y en la APK.
 - La planificación no modifica ni cierra Actas/hallazgos previos.
 - La verificación en campo se registra append-only.
@@ -1,6 +1,6 @@
 {
  "name": "dhv2-web",
-  "version": "0.20.0-4",
+  "version": "0.20.0-3",
  "private": true,
  "type": "module",
  "engines": {
@@ -37,8 +37,8 @@ import { ActAdministrationDetailPage } from '../pages/ActAdministrationDetailPag
 import { FieldBriefingsPage } from '../pages/FieldBriefingsPage';
 const MapPage = lazy(() => import('../pages/MapPage').then((module) => ({ default: module.MapPage })));
 const DocumentDeliveryPage = lazy(() => import('../pages/DocumentDeliveryPage').then((module) => ({ default: module.DocumentDeliveryPage })));
 export function App() {
  return <Suspense fallback={<div className="loading-block"><span className="spinner" />Cargando módulo…</div>}><Routes>
    <Route path="/login" element={<LoginPage />} />
@@ -1,2 +1,2 @@
-export const APP_VERSION = '0.20.0-4';
+export const APP_VERSION = '0.20.0-3';
-export const APP_PHASE = 'Fase F1.4 · Briefing contextual antes de salir';
+export const APP_PHASE = 'Fase F1.3 · Preparación inteligente de campo';
@@ -1,97 +0,0 @@
 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>;
 }
@@ -6,7 +6,6 @@ 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 }) {
@@ -26,18 +25,17 @@ export function InspectionActsPanel({ visit }: { visit: InspectionVisit }) {
      .finally(() => setLoading(false));
  }, [canRead, visit.id]);
-  return <>
+  if (!canRead) return null;
-    <FieldBriefingPanel visit={visit} />
+
-    {canRead && <section className="inspection-acts-panel">
+  return <section className="inspection-acts-panel">
-      <div className="panel-heading">
+    <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>
+      <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>
+      <span className="status-badge pending">Sólo lectura</span>
-      </div>
+    </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>
+    <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>}
+    {error && <Alert>{error}</Alert>}
-      {loading ? <LoadingBlock label="Cargando actas…" /> : acts.length === 0
+    {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.'} />
+      ? <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>}
+      : <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>}
+  </section>;
  </>;
 }
@@ -1,56 +0,0 @@
 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`);
 }
@@ -4,13 +4,7 @@ import { SearchableSelect } from '../components/SearchableSelect';
 import { Alert, EmptyState, LoadingBlock } from '../components/Feedback';
 import { formatDate, formatDateOnly } from '../lib/format';
-type AdminState =
+type ReviewState = 'REQUIRED' | 'UPCOMING' | 'CONTEXT';
  | 'ACT_RESPONSE_OVERDUE'
  | 'ACT_RESPONSE_DUE_SOON'
  | 'WAITING_RESPONSE'
  | 'COMPANY_COMMITMENT_OVERDUE'
  | 'VERIFICATION_PENDING'
  | 'RESPONSE_RECEIVED';
 interface VisitOption {
  id: string;
@@ -25,100 +19,79 @@ interface BriefingFinding {
  id: string;
  code: string;
  title: string;
  status: string;
  severity: number | null;
  nextControlOn: string | null;
-  asset: {
+  reviewState: ReviewState;
-    id: string;
+  reviewReason: string;
-    code: string;
+  asset: { id: string; code: string; name: string; typeName: string };
    name: string;
    typeName: string;
  };
 }
 interface BriefingAct {
  actId: string;
  actCode: string;
  occurredAt: string;
-  adminState: AdminState;
+  adminState: string;
  responseDueOn: string | null;
-  responseReceivedOn: string | null;
+  latestResponse: null | { id: string; receivedOn: string; committedCorrectionOn: string | null; hasPdf: boolean };
  committedCorrectionOn: string | null;
  latestResponseId: string | null;
  findings: BriefingFinding[];
 }
-interface FieldBriefing {
+interface Briefing {
-  inspection: {
+  visit: {
    id: string;
    code: string;
    status: string;
    plannedStartAt: string | null;
-    area: { id: string; code: string | null; name: string | null } | null;
+    operationalArea: { id: string; code: string | null; name: string | null };
-    operatorCompany: { id: string; code: string | null; name: string | null } | null;
+    operatorCompany: { id: string; code: string | null; name: string | null };
  };
-  plannedOn: string;
+  referenceDate: string;
  generatedAt: string;
  summary: {
-    acts: number;
+    actCount: number;
-    findings: number;
+    openFindingCount: number;
-    inventoryItems: number;
+    fieldReviewRequired: number;
-    responseOverdue: number;
+    fieldReviewUpcoming: number;
-    commitmentOverdue: number;
+    administrativeAttention: number;
-    verificationPending: number;
+    assetCount: number;
  };
  acts: BriefingAct[];
 }
-async function getJson<T>(url: string): Promise<T> {
+async function json<T>(url: string): Promise<T> {
-  const response = await fetch(url, {
+  const response = await fetch(url, { credentials: 'same-origin', headers: { Accept: 'application/json' } });
    credentials: 'same-origin',
    headers: { Accept: 'application/json' },
  });
  const payload = await response.json().catch(() => ({}));
  if (!response.ok) {
    const message = typeof payload?.message === 'string'
      ? payload.message
-      : 'No se pudo preparar el paquete de campo.';
+      : 'No se pudo cargar la preparación de campo.';
    throw new Error(message);
  }
  return payload as T;
 }
-function adminStateLabel(state: AdminState): string {
+function reviewLabel(state: ReviewState) {
-  const labels: Record<AdminState, string> = {
+  if (state === 'REQUIRED') return 'Revisar en campo';
-    ACT_RESPONSE_OVERDUE: 'Respuesta del Acta vencida',
+  if (state === 'UPCOMING') return 'Próximo control';
-    ACT_RESPONSE_DUE_SOON: 'Respuesta próxima a vencer',
+  return 'Antecedente';
    WAITING_RESPONSE: 'Esperando respuesta',
    COMPANY_COMMITMENT_OVERDUE: 'Compromiso de empresa vencido',
    VERIFICATION_PENDING: 'Verificación pendiente',
    RESPONSE_RECEIVED: 'Respuesta recibida',
  };
  return labels[state];
 }
-function findingAction(finding: BriefingFinding, act: BriefingAct, plannedOn: string) {
+function reasonLabel(reason: string) {
-  if (finding.nextControlOn) {
+  const labels: Record<string, string> = {
-    if (finding.nextControlOn <= plannedOn) {
+    CONTROL_OVERDUE: 'Control vencido',
-      return { label: 'Revisar en campo', detail: 'Control programado o vencido', tone: 'danger' };
+    COMMITMENT_REACHED: 'Compromiso de empresa alcanzado',
-    }
+    RESPONSE_WITHOUT_CONTROL: 'Respuesta recibida sin control programado',
-    return { label: 'Próximo control', detail: `Previsto ${formatDateOnly(finding.nextControlOn)}`, tone: 'pending' };
+    CONTROL_UPCOMING: 'Control próximo',
-  }
+    ADMIN_RESPONSE_OVERDUE: 'Respuesta administrativa vencida',
-  if (act.adminState === 'VERIFICATION_PENDING') {
+    CONTEXT_ONLY: 'Antecedente abierto',
-    return { label: 'Revisar en campo', detail: 'Respuesta recibida sin control programado', tone: 'danger' };
+  };
-  }
+  return labels[reason] ?? reason;
  if (act.adminState === 'COMPANY_COMMITMENT_OVERDUE') {
    return { label: 'Revisar en campo', detail: 'Regularización comprometida vencida', tone: 'danger' };
  }
  if (act.adminState === 'RESPONSE_RECEIVED') {
    return { label: 'Antecedente', detail: 'Respuesta de empresa recibida', tone: 'pending' };
  }
  return { label: 'Antecedente', detail: adminStateLabel(act.adminState), tone: 'pending' };
 }
 export function FieldBriefingsPage() {
  const [visits, setVisits] = useState<VisitOption[]>([]);
  const [visitId, setVisitId] = useState('');
-  const [briefing, setBriefing] = useState<FieldBriefing | null>(null);
+  const [briefing, setBriefing] = useState<Briefing | null>(null);
  const [loadingVisits, setLoadingVisits] = useState(true);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');
@@ -126,17 +99,16 @@ export function FieldBriefingsPage() {
  useEffect(() => {
    setLoadingVisits(true);
    Promise.all([
-      getJson<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=PLANNED&page=1&pageSize=100'),
+      json<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=PLANNED&page=1&pageSize=100'),
-      getJson<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=DRAFT&page=1&pageSize=100'),
+      json<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=DRAFT&page=1&pageSize=100'),
    ]).then(([planned, drafts]) => {
      const all = [...planned.data, ...drafts.data]
        .sort((a, b) => String(a.plannedStartAt ?? '').localeCompare(String(b.plannedStartAt ?? '')));
      setVisits(all);
      const onlyVisit = all[0];
      if (all.length === 1 && onlyVisit) setVisitId(onlyVisit.id);
-    }).catch((cause) => {
+    }).catch((cause) => setError(cause instanceof Error ? cause.message : String(cause)))
-      setError(cause instanceof Error ? cause.message : String(cause));
+      .finally(() => setLoadingVisits(false));
    }).finally(() => setLoadingVisits(false));
  }, []);
  useEffect(() => {
@@ -146,27 +118,22 @@ export function FieldBriefingsPage() {
    }
    setLoading(true);
    setError('');
-    getJson<FieldBriefing>(`/api/v3/inspection-visits/${visitId}/field-briefing`)
+    json<Briefing>(`/api/v3/inspection-visits/${visitId}/field-briefing`)
      .then(setBriefing)
      .catch((cause) => setError(cause instanceof Error ? cause.message : String(cause)))
      .finally(() => setLoading(false));
  }, [visitId]);
-  const selected = useMemo(
+  const selected = useMemo(() => visits.find((visit) => visit.id === visitId) ?? null, [visits, visitId]);
    () => visits.find((visit) => visit.id === visitId) ?? null,
    [visits, visitId],
  );
  return <section className="field-briefing-page">
    <div className="page-heading">
      <div>
        <span className="eyebrow">ANTES DE SALIR A CAMPO</span>
        <h1>Preparación de campo</h1>
-        <p>Seleccioná la inspección y revisá los pendientes de Actas anteriores del mismo Área/Yacimiento y Operadora.</p>
+        <p>Actas anteriores y hallazgos abiertos del mismo Área/Yacimiento y Operadora, ordenados por lo que el inspector debe revisar.</p>
      </div>
-      {briefing && <button className="button secondary no-print" type="button" onClick={() => window.print()}>
+      {briefing && <button className="button secondary" type="button" onClick={() => window.print()}>Imprimir preparación</button>}
        Imprimir preparación
      </button>}
    </div>
    <div className="form-card no-print">
@@ -186,79 +153,39 @@ export function FieldBriefingsPage() {
    {error && <Alert>{error}</Alert>}
    {loading && <LoadingBlock label="Armando paquete de campo…" />}
-
+    {!loading && !briefing && !error && <EmptyState title="Seleccioná una inspección" text="El sistema reunirá automáticamente los pendientes de inspecciones anteriores." />}
    {!loading && !briefing && !error && <EmptyState
      title="Seleccioná una inspección"
      text="El sistema reunirá automáticamente los pendientes de inspecciones anteriores del mismo contexto."
    />}
    {!loading && briefing && <>
      <div className="page-heading compact">
        <div>
-          <span className="eyebrow">{briefing.inspection.code}</span>
+          <span className="eyebrow">{briefing.visit.code}</span>
-          <h2>{briefing.inspection.area?.name ?? 'Área sin definir'} · {briefing.inspection.operatorCompany?.name ?? 'Operadora sin definir'}</h2>
+          <h2>{briefing.visit.operationalArea.name ?? 'Área'} · {briefing.visit.operatorCompany.name ?? 'Operadora'}</h2>
-          <p>Fecha de referencia: {formatDateOnly(briefing.plannedOn)}</p>
+          <p>Referencia: {formatDateOnly(briefing.referenceDate)} · generado {formatDate(briefing.generatedAt)}</p>
        </div>
-        <Link className="button secondary no-print" to={`/inspecciones/${briefing.inspection.id}`}>
+        <Link className="button secondary no-print" to={`/inspecciones/${briefing.visit.id}`}>Abrir planificación</Link>
          Abrir planificación
        </Link>
      </div>
      <div className="status-tabs briefing-summary">
-        <span>Actas <strong>{briefing.summary.acts}</strong></span>
+        <span>Actas <strong>{briefing.summary.actCount}</strong></span>
-        <span>Hallazgos <strong>{briefing.summary.findings}</strong></span>
+        <span>Hallazgos abiertos <strong>{briefing.summary.openFindingCount}</strong></span>
-        <span>Inventario <strong>{briefing.summary.inventoryItems}</strong></span>
+        <span>Revisar en campo <strong>{briefing.summary.fieldReviewRequired}</strong></span>
-        <span>Respuestas vencidas <strong>{briefing.summary.responseOverdue}</strong></span>
+        <span>Próximos <strong>{briefing.summary.fieldReviewUpcoming}</strong></span>
-        <span>Compromisos vencidos <strong>{briefing.summary.commitmentOverdue}</strong></span>
+        <span>Inventario involucrado <strong>{briefing.summary.assetCount}</strong></span>
        <span>Verificaciones pendientes <strong>{briefing.summary.verificationPending}</strong></span>
      </div>
-      {briefing.acts.length === 0 ? <EmptyState
+      {briefing.acts.length === 0 ? <EmptyState title="Sin pendientes anteriores" text="No hay hallazgos abiertos de Actas anteriores para este contexto." /> : briefing.acts.map((act) => <article className="table-panel" key={act.actId}>
        title="Sin pendientes anteriores"
        text="No hay Actas anteriores con hallazgos abiertos que requieran atención para esta inspección."
      /> : briefing.acts.map((act) => <article className="table-panel" key={act.actId}>
        <div className="table-summary">
-          <div>
+          <div><strong>{act.actCode}</strong><small className="block-muted">{formatDate(act.occurredAt)} · {act.adminState}</small></div>
-            <strong>{act.actCode}</strong>
+          <div><small>Plazo empresa</small><strong>{act.responseDueOn ? formatDateOnly(act.responseDueOn) : 'Sin definir'}</strong></div>
-            <small className="block-muted">{formatDate(act.occurredAt)} · {adminStateLabel(act.adminState)}</small>
+          <div><small>Respuesta</small><strong>{act.latestResponse ? formatDateOnly(act.latestResponse.receivedOn) : 'Pendiente'}</strong></div>
          </div>
          <div>
            <small>Plazo del Acta</small>
            <strong>{act.responseDueOn ? formatDateOnly(act.responseDueOn) : 'Sin definir'}</strong>
          </div>
          <div>
            <small>Respuesta empresa</small>
            <strong>{act.responseReceivedOn ? formatDateOnly(act.responseReceivedOn) : 'Pendiente'}</strong>
          </div>
          <div>
            <small>Compromiso empresa</small>
            <strong>{act.committedCorrectionOn ? formatDateOnly(act.committedCorrectionOn) : 'Sin fecha'}</strong>
          </div>
        </div>
        <div className="table-scroll">
          <table>
            <thead><tr><th>Qué hacer</th><th>Hallazgo</th><th>Inventario</th><th>Control</th></tr></thead>
            <tbody>{act.findings.map((finding) => {
              const action = findingAction(finding, act, briefing.plannedOn);
              return <tr key={finding.id}>
                <td>
                  <span className={`status-badge ${action.tone}`}>{action.label}</span>
                  <small className="block-muted">{action.detail}</small>
                </td>
                <td>
                  <strong>{finding.code}</strong>
                  <small className="block-muted">{finding.title}</small>
                </td>
                <td>
                  <strong>{finding.asset.code}</strong>
                  <small className="block-muted">{finding.asset.name} · {finding.asset.typeName}</small>
                </td>
                <td>{finding.nextControlOn ? formatDateOnly(finding.nextControlOn) : 'Sin fecha'}</td>
              </tr>;
            })}</tbody>
          </table>
        </div>
        <div className="table-scroll"><table><thead><tr><th>Prioridad</th><th>Hallazgo</th><th>Inventario</th><th>Próximo control</th></tr></thead><tbody>
          {act.findings.map((finding) => <tr key={finding.id}>
            <td><span className={`status-badge ${finding.reviewState === 'REQUIRED' ? 'danger' : 'pending'}`}>{reviewLabel(finding.reviewState)}</span><small className="block-muted">{reasonLabel(finding.reviewReason)}</small></td>
            <td><strong>{finding.code}</strong><small className="block-muted">{finding.title}</small></td>
            <td><strong>{finding.asset.code}</strong><small className="block-muted">{finding.asset.name} · {finding.asset.typeName}</small></td>
            <td>{finding.nextControlOn ? formatDateOnly(finding.nextControlOn) : 'Sin fecha'}</td>
          </tr>)}
        </tbody></table></div>
      </article>)}
    </>}
  </section>;
Author	SHA1	Message	Date
admin	b8c002f36a	fix(F1.3): asegurar visita única en build estricto	2026-09-05 17:08:27 -03:00
admin	da7d8a9149	F1.3 · Preparación inteligente de campo Agrega paquete de campo por inspección con Actas anteriores del mismo contexto, hallazgos abiertos priorizados para verificación y vista web imprimible.	2026-09-05 17:05:46 -03:00
`@@ -1,2 +1,2 @@`
	`export const API_VERSION = '0.21.0-1';`	`export const API_VERSION = '0.20.0-3';`
	`export const API_PHASE = 'F2.1';`	`export const API_PHASE = 'F1.3';`
`@@ -1,2 +1,2 @@`
	`export const APP_VERSION = '0.20.0-4';`	`export const APP_VERSION = '0.20.0-3';`
	`export const APP_PHASE = 'Fase F1.4 · Briefing contextual antes de salir';`	`export const APP_PHASE = 'Fase F1.3 · Preparación inteligente de campo';`