From 48bbe293d94a68be8addb951ac8cdb90e4d7b8ee Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:43:40 -0300
Subject: [PATCH 001/224] feat(f4): extend act lifecycle and deadline snapshot

---
 .../entities/inspection-act.entity.ts         | 53 ++++++++++++++++++-
 1 file changed, 52 insertions(+), 1 deletion(-)

diff --git a/api-v3/src/database/entities/inspection-act.entity.ts b/api-v3/src/database/entities/inspection-act.entity.ts
index d7e57be..3e9021f 100644
--- a/api-v3/src/database/entities/inspection-act.entity.ts
+++ b/api-v3/src/database/entities/inspection-act.entity.ts
@@ -3,12 +3,29 @@ import { TimestampedEntity } from './timestamped.entity';
 
 export enum InspectionActStatus {
   DRAFT = 'DRAFT',
+  LOCKED = 'LOCKED',
+  SEALED = 'SEALED',
   READY = 'READY',
   CLOSED = 'CLOSED',
   CANCELLED = 'CANCELLED',
   RECTIFIED = 'RECTIFIED',
 }
 
+export enum InspectionActUrgency {
+  URGENT = 'URGENT',
+  NON_URGENT = 'NON_URGENT',
+}
+
+export enum InspectionDeadlineDayType {
+  BUSINESS = 'BUSINESS',
+  CALENDAR = 'CALENDAR',
+}
+
+export enum InspectionDeadlineBasis {
+  ACT_DATE = 'ACT_DATE',
+  GEDO_DATE = 'GEDO_DATE',
+}
+
 @Entity({ name: 'inspection_acts' })
 @Index('uq_inspection_acts_one_draft_per_visit', ['visitId'], { unique: true, where: "status = 'DRAFT'" })
 @Index('uq_inspection_acts_year_number', ['actYear', 'actNumber'], { unique: true })
@@ -16,6 +33,7 @@ export enum InspectionActStatus {
 @Index('idx_inspection_acts_visit_status', ['visitId', 'status'])
 @Index('idx_inspection_acts_occurred_at', ['occurredAt'])
 @Index('idx_inspection_acts_created_by', ['createdBy'])
+@Index('idx_inspection_acts_deadline', ['deadlineAt'])
 export class InspectionAct extends TimestampedEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string;
@@ -29,7 +47,7 @@ export class InspectionAct extends TimestampedEntity {
   @Column({ name: 'act_number', type: 'integer' })
   actNumber!: number;
 
-  @Column({ type: 'varchar', length: 24 })
+  @Column({ type: 'varchar', length: 40 })
   code!: string;
 
   @Column({ type: 'varchar', length: 24, default: InspectionActStatus.DRAFT })
@@ -47,6 +65,39 @@ export class InspectionAct extends TimestampedEntity {
   @Column({ type: 'text', nullable: true })
   observations!: string | null;
 
+  @Column({ name: 'urgency', type: 'varchar', length: 24, default: InspectionActUrgency.NON_URGENT })
+  urgency!: InspectionActUrgency;
+
+  @Column({ name: 'deadline_days', type: 'integer', nullable: true })
+  deadlineDays!: number | null;
+
+  @Column({ name: 'deadline_day_type', type: 'varchar', length: 24, nullable: true })
+  deadlineDayType!: InspectionDeadlineDayType | null;
+
+  @Column({ name: 'deadline_basis', type: 'varchar', length: 24, nullable: true })
+  deadlineBasis!: InspectionDeadlineBasis | null;
+
+  @Column({ name: 'deadline_base_at', type: 'timestamptz', nullable: true })
+  deadlineBaseAt!: Date | null;
+
+  @Column({ name: 'deadline_at', type: 'timestamptz', nullable: true })
+  deadlineAt!: Date | null;
+
+  @Column({ name: 'locked_at', type: 'timestamptz', nullable: true })
+  lockedAt!: Date | null;
+
+  @Column({ name: 'locked_by', type: 'uuid', nullable: true })
+  lockedBy!: string | null;
+
+  @Column({ name: 'locked_sha256', type: 'char', length: 64, nullable: true })
+  lockedSha256!: string | null;
+
+  @Column({ name: 'sealed_at', type: 'timestamptz', nullable: true })
+  sealedAt!: Date | null;
+
+  @Column({ name: 'sealed_by', type: 'uuid', nullable: true })
+  sealedBy!: string | null;
+
   @Column({ name: 'current_version', type: 'integer', default: 0 })
   currentVersion!: number;
 

From 7a41ce25ad6d8d0a2e1c6f534df0ff27e1a3a220 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:43:55 -0300
Subject: [PATCH 002/224] feat(f4): add finding recurrence linkage

---
 .../src/database/entities/inspection-finding.entity.ts   | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/api-v3/src/database/entities/inspection-finding.entity.ts b/api-v3/src/database/entities/inspection-finding.entity.ts
index e1f5a69..67e3631 100644
--- a/api-v3/src/database/entities/inspection-finding.entity.ts
+++ b/api-v3/src/database/entities/inspection-finding.entity.ts
@@ -1,6 +1,7 @@
 import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
 import { TimestampedEntity } from './timestamped.entity';
 
+/** @deprecated Los plazos de respuesta pasan al nivel Acta/Informe en F4. */
 export enum InspectionFindingResponseDueBasis {
   FINDING_DATE = 'FINDING_DATE',
   REPORT_NOTIFICATION = 'REPORT_NOTIFICATION',
@@ -18,6 +19,7 @@ export enum InspectionFindingStatus {
 @Index('idx_inspection_findings_status_control', ['status', 'nextControlOn'])
 @Index('idx_inspection_findings_asset_status', ['assetId', 'status'])
 @Index('idx_inspection_findings_catalog_item', ['catalogItemId'])
+@Index('idx_inspection_findings_recurrence_of', ['recurrenceOfFindingId'])
 export class InspectionFinding extends TimestampedEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string;
@@ -61,9 +63,16 @@ export class InspectionFinding extends TimestampedEntity {
   @Column({ type: 'smallint', nullable: true })
   severity!: number | null;
 
+  @Column({ name: 'is_recurrence', type: 'boolean', default: false })
+  isRecurrence!: boolean;
+
+  @Column({ name: 'recurrence_of_finding_id', type: 'uuid', nullable: true })
+  recurrenceOfFindingId!: string | null;
+
   @Column({ name: 'correction_due_on', type: 'date', nullable: true })
   correctionDueOn!: string | null;
 
+  // Campos legacy conservados temporalmente para migrar datos sin pérdida.
   @Column({ name: 'response_due_basis', type: 'varchar', length: 32, nullable: true })
   responseDueBasis!: InspectionFindingResponseDueBasis | null;
 

From a9efd71367a099e850a9fb54e49ba5b2b84427bc Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:44:12 -0300
Subject: [PATCH 003/224] feat(f4): extend INF with GEDO officialization

---
 .../entities/inspection-report.entity.ts      | 36 +++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/api-v3/src/database/entities/inspection-report.entity.ts b/api-v3/src/database/entities/inspection-report.entity.ts
index 77c4291..7742475 100644
--- a/api-v3/src/database/entities/inspection-report.entity.ts
+++ b/api-v3/src/database/entities/inspection-report.entity.ts
@@ -2,6 +2,8 @@ import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
 import { TimestampedEntity } from './timestamped.entity';
 
 export enum InspectionReportStatus {
+  WORKING = 'WORKING',
+  OFFICIALIZED = 'OFFICIALIZED',
   FROZEN = 'FROZEN',
   CANCELLED = 'CANCELLED',
 }
@@ -18,6 +20,7 @@ export enum InspectionReportWordStatus {
   FAILED = 'FAILED',
 }
 
+/** @deprecated El circuito Director/aprobación/firma se retira en F4. */
 export enum InspectionReportReviewStatus {
   PENDING_REVIEW = 'PENDING_REVIEW',
   APPROVED = 'APPROVED',
@@ -31,6 +34,7 @@ export enum InspectionReportReviewStatus {
 @Index('uq_inspection_reports_code', ['code'], { unique: true })
 @Index('idx_inspection_reports_generated_at', ['generatedAt'])
 @Index('idx_inspection_reports_status', ['status', 'pdfStatus'])
+@Index('idx_inspection_reports_gedo_officialized_at', ['gedoOfficializedAt'])
 export class InspectionReport extends TimestampedEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string;
@@ -47,12 +51,39 @@ export class InspectionReport extends TimestampedEntity {
   @Column({ name: 'report_number', type: 'integer' })
   reportNumber!: number;
 
-  @Column({ type: 'varchar', length: 24 })
+  @Column({ type: 'varchar', length: 40 })
   code!: string;
 
-  @Column({ type: 'varchar', length: 24, default: InspectionReportStatus.FROZEN })
+  @Column({ type: 'varchar', length: 24, default: InspectionReportStatus.WORKING })
   status!: InspectionReportStatus;
 
+  @Column({ name: 'executive_summary', type: 'text', nullable: true })
+  executiveSummary!: string | null;
+
+  @Column({ name: 'report_description', type: 'text', nullable: true })
+  reportDescription!: string | null;
+
+  @Column({ name: 'gedo_if_identifier', type: 'varchar', length: 255, nullable: true })
+  gedoIfIdentifier!: string | null;
+
+  @Column({ name: 'gedo_officialized_at', type: 'timestamptz', nullable: true })
+  gedoOfficializedAt!: Date | null;
+
+  @Column({ name: 'gedo_pdf_original_name', type: 'varchar', length: 255, nullable: true })
+  gedoPdfOriginalName!: string | null;
+
+  @Column({ name: 'gedo_pdf_stored_name', type: 'varchar', length: 255, nullable: true })
+  gedoPdfStoredName!: string | null;
+
+  @Column({ name: 'gedo_pdf_mime_type', type: 'varchar', length: 120, nullable: true })
+  gedoPdfMimeType!: string | null;
+
+  @Column({ name: 'gedo_pdf_size_bytes', type: 'integer', nullable: true })
+  gedoPdfSizeBytes!: number | null;
+
+  @Column({ name: 'gedo_pdf_sha256', type: 'char', length: 64, nullable: true })
+  gedoPdfSha256!: string | null;
+
   @Column({ name: 'pdf_status', type: 'varchar', length: 24, default: InspectionReportPdfStatus.PENDING })
   pdfStatus!: InspectionReportPdfStatus;
 
@@ -80,6 +111,7 @@ export class InspectionReport extends TimestampedEntity {
   @Column({ name: 'word_error', type: 'varchar', length: 500, nullable: true })
   wordError!: string | null;
 
+  // Campos legacy del circuito Director, conservados sólo hasta completar la migración F4.
   @Column({ name: 'review_status', type: 'varchar', length: 32, default: InspectionReportReviewStatus.PENDING_REVIEW })
   reviewStatus!: InspectionReportReviewStatus;
 

From 52a068c81754667d90958aa4177766a9a6980b6f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:44:21 -0300
Subject: [PATCH 004/224] feat(f4): add JEFE-managed act deadline policy

---
 .../inspection-deadline-policy.entity.ts      | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 api-v3/src/database/entities/inspection-deadline-policy.entity.ts

diff --git a/api-v3/src/database/entities/inspection-deadline-policy.entity.ts b/api-v3/src/database/entities/inspection-deadline-policy.entity.ts
new file mode 100644
index 0000000..9072f55
--- /dev/null
+++ b/api-v3/src/database/entities/inspection-deadline-policy.entity.ts
@@ -0,0 +1,24 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { InspectionDeadlineDayType } from './inspection-act.entity';
+import { TimestampedEntity } from './timestamped.entity';
+
+@Entity({ name: 'inspection_deadline_policies' })
+export class InspectionDeadlinePolicy extends TimestampedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ name: 'urgent_days', type: 'integer', default: 5 })
+  urgentDays!: number;
+
+  @Column({ name: 'urgent_day_type', type: 'varchar', length: 24, default: InspectionDeadlineDayType.BUSINESS })
+  urgentDayType!: InspectionDeadlineDayType;
+
+  @Column({ name: 'non_urgent_days', type: 'integer', default: 10 })
+  nonUrgentDays!: number;
+
+  @Column({ name: 'non_urgent_day_type', type: 'varchar', length: 24, default: InspectionDeadlineDayType.BUSINESS })
+  nonUrgentDayType!: InspectionDeadlineDayType;
+
+  @Column({ name: 'updated_by', type: 'uuid', nullable: true })
+  updatedBy!: string | null;
+}

From 2fb48ec41e01e9891a28729869d47870d37c2bd1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:44:27 -0300
Subject: [PATCH 005/224] feat(f4): add business-day calendar overrides

---
 ...inspection-business-calendar-day.entity.ts | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 api-v3/src/database/entities/inspection-business-calendar-day.entity.ts

diff --git a/api-v3/src/database/entities/inspection-business-calendar-day.entity.ts b/api-v3/src/database/entities/inspection-business-calendar-day.entity.ts
new file mode 100644
index 0000000..0a7752f
--- /dev/null
+++ b/api-v3/src/database/entities/inspection-business-calendar-day.entity.ts
@@ -0,0 +1,21 @@
+import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
+import { TimestampedEntity } from './timestamped.entity';
+
+@Entity({ name: 'inspection_business_calendar_days' })
+@Index('uq_inspection_business_calendar_day', ['date'], { unique: true })
+export class InspectionBusinessCalendarDay extends TimestampedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ type: 'date' })
+  date!: string;
+
+  @Column({ name: 'is_business_day', type: 'boolean', default: false })
+  isBusinessDay!: boolean;
+
+  @Column({ type: 'varchar', length: 200 })
+  label!: string;
+
+  @Column({ name: 'updated_by', type: 'uuid', nullable: true })
+  updatedBy!: string | null;
+}

From 13f2dcfa959b54d5d17eb0506d1e4cad3b2e57ba Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:44:34 -0300
Subject: [PATCH 006/224] feat(f4): add append-only INF follow-up timeline

---
 .../inspection-report-follow-up.entity.ts     | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 api-v3/src/database/entities/inspection-report-follow-up.entity.ts

diff --git a/api-v3/src/database/entities/inspection-report-follow-up.entity.ts b/api-v3/src/database/entities/inspection-report-follow-up.entity.ts
new file mode 100644
index 0000000..e7b26e4
--- /dev/null
+++ b/api-v3/src/database/entities/inspection-report-follow-up.entity.ts
@@ -0,0 +1,50 @@
+import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
+import { TimestampedEntity } from './timestamped.entity';
+
+export enum InspectionReportFollowUpType {
+  COMPANY_NOTE = 'COMPANY_NOTE',
+  COMPANY_DOCUMENT = 'COMPANY_DOCUMENT',
+  INTERNAL_NOTE = 'INTERNAL_NOTE',
+  VERIFICATION = 'VERIFICATION',
+  OTHER = 'OTHER',
+}
+
+@Entity({ name: 'inspection_report_follow_ups' })
+@Index('idx_inspection_report_follow_ups_report_created', ['reportId', 'createdAt'])
+export class InspectionReportFollowUp extends TimestampedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ name: 'report_id', type: 'uuid' })
+  reportId!: string;
+
+  @Column({ type: 'varchar', length: 40 })
+  type!: InspectionReportFollowUpType;
+
+  @Column({ name: 'external_reference', type: 'varchar', length: 255, nullable: true })
+  externalReference!: string | null;
+
+  @Column({ name: 'occurred_at', type: 'timestamptz' })
+  occurredAt!: Date;
+
+  @Column({ type: 'text', nullable: true })
+  description!: string | null;
+
+  @Column({ name: 'original_name', type: 'varchar', length: 255, nullable: true })
+  originalName!: string | null;
+
+  @Column({ name: 'stored_name', type: 'varchar', length: 255, nullable: true })
+  storedName!: string | null;
+
+  @Column({ name: 'mime_type', type: 'varchar', length: 120, nullable: true })
+  mimeType!: string | null;
+
+  @Column({ name: 'size_bytes', type: 'integer', nullable: true })
+  sizeBytes!: number | null;
+
+  @Column({ name: 'sha256', type: 'char', length: 64, nullable: true })
+  sha256!: string | null;
+
+  @Column({ name: 'created_by', type: 'uuid', nullable: true })
+  createdBy!: string | null;
+}

From ab665e51b51bf763dbe919a995ec3d681fdd6adf Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:44:42 -0300
Subject: [PATCH 007/224] feat(f4): add superadmin SMTP settings entity

---
 .../entities/system-smtp-settings.entity.ts   | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 api-v3/src/database/entities/system-smtp-settings.entity.ts

diff --git a/api-v3/src/database/entities/system-smtp-settings.entity.ts b/api-v3/src/database/entities/system-smtp-settings.entity.ts
new file mode 100644
index 0000000..06ae268
--- /dev/null
+++ b/api-v3/src/database/entities/system-smtp-settings.entity.ts
@@ -0,0 +1,44 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { TimestampedEntity } from './timestamped.entity';
+
+export enum SmtpSecurityMode {
+  NONE = 'NONE',
+  STARTTLS = 'STARTTLS',
+  TLS = 'TLS',
+}
+
+@Entity({ name: 'system_smtp_settings' })
+export class SystemSmtpSettings extends TimestampedEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ type: 'varchar', length: 255 })
+  host!: string;
+
+  @Column({ type: 'integer' })
+  port!: number;
+
+  @Column({ name: 'security_mode', type: 'varchar', length: 24, default: SmtpSecurityMode.STARTTLS })
+  securityMode!: SmtpSecurityMode;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  username!: string | null;
+
+  @Column({ name: 'password_enc', type: 'text', nullable: true })
+  passwordEnc!: string | null;
+
+  @Column({ name: 'from_name', type: 'varchar', length: 200 })
+  fromName!: string;
+
+  @Column({ name: 'from_email', type: 'varchar', length: 320 })
+  fromEmail!: string;
+
+  @Column({ name: 'reply_to', type: 'varchar', length: 320, nullable: true })
+  replyTo!: string | null;
+
+  @Column({ type: 'boolean', default: true })
+  enabled!: boolean;
+
+  @Column({ name: 'updated_by', type: 'uuid', nullable: true })
+  updatedBy!: string | null;
+}

From 0f1164fae8274d81f9c17d6c10631d3e7ef80fa7 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:45:04 -0300
Subject: [PATCH 008/224] feat(f4): register deadline, follow-up and SMTP
 entities

---
 api-v3/src/database/entities/index.ts | 99 +++++++++------------------
 1 file changed, 31 insertions(+), 68 deletions(-)

diff --git a/api-v3/src/database/entities/index.ts b/api-v3/src/database/entities/index.ts
index 4b9d2e4..cd1cff6 100644
--- a/api-v3/src/database/entities/index.ts
+++ b/api-v3/src/database/entities/index.ts
@@ -6,14 +6,8 @@ export { Role } from './role.entity';
 export { UserRole } from './user-role.entity';
 export { User, UserStatus } from './user.entity';
 export { Asset, AssetDataOrigin, AssetInformationStatus, AssetOperationalStatus } from './asset.entity';
-export {
-  AssetVersion,
-  AssetVersionChangeType,
-} from './asset-version.entity';
-export {
-  AssetAttributeDataType,
-  AssetAttributeDefinition,
-} from './asset-attribute-definition.entity';
+export { AssetVersion, AssetVersionChangeType } from './asset-version.entity';
+export { AssetAttributeDataType, AssetAttributeDefinition } from './asset-attribute-definition.entity';
 export { AssetAttributeValue } from './asset-attribute-value.entity';
 export { AreaCompanyRelation, AreaOrganizationRole } from './area-company-relation.entity';
 export { OrganizationProfile, OrganizationKind } from './organization-profile.entity';
@@ -25,47 +19,23 @@ export { AreaLegalRight, AreaLegalRightType, AreaLegalRightStatus } from './area
 export { AreaLegalRightOrganization, AreaLegalRightOrganizationRole } from './area-legal-right-organization.entity';
 export { AssetTypeParentRule } from './asset-type-parent-rule.entity';
 export { AssetType, AssetTypeOperationalRole } from './asset-type.entity';
-export {
-  AssetGeometry,
-  AssetGeometrySource,
-  AssetGeometryType,
-} from './asset-geometry.entity';
-export {
-  AssetMedia,
-  AssetMediaKind,
-  AssetMediaSource,
-} from './asset-media.entity';
-export {
-  SurveyCampaign,
-  SurveyCampaignStatus,
-} from './survey-campaign.entity';
-export {
-  SurveyCampaignTarget,
-  SurveyTargetStatus,
-} from './survey-campaign-target.entity';
-export {
-  SurveyReportOutcome,
-  SurveyReportStatus,
-  SurveyTargetReport,
-} from './survey-target-report.entity';
+export { AssetGeometry, AssetGeometrySource, AssetGeometryType } from './asset-geometry.entity';
+export { AssetMedia, AssetMediaKind, AssetMediaSource } from './asset-media.entity';
+export { SurveyCampaign, SurveyCampaignStatus } from './survey-campaign.entity';
+export { SurveyCampaignTarget, SurveyTargetStatus } from './survey-campaign-target.entity';
+export { SurveyReportOutcome, SurveyReportStatus, SurveyTargetReport } from './survey-target-report.entity';
 export { SurveyTargetReportMedia } from './survey-target-report-media.entity';
-export {
-  SurveyReportVersionEvent,
-  SurveyTargetReportVersion,
-} from './survey-target-report-version.entity';
-export {
-  InspectionVisit,
-  InspectionVisitStatus,
-} from './inspection-visit.entity';
+export { SurveyReportVersionEvent, SurveyTargetReportVersion } from './survey-target-report-version.entity';
+export { InspectionVisit, InspectionVisitStatus } from './inspection-visit.entity';
 export { InspectionVisitAsset, InspectionVisitAssetPlanningSource } from './inspection-visit-asset.entity';
 export { InspectionVisitMember } from './inspection-visit-member.entity';
-export {
-  DocumentAnnualSequence,
-  DocumentSequenceType,
-} from './document-annual-sequence.entity';
+export { DocumentAnnualSequence, DocumentSequenceType } from './document-annual-sequence.entity';
 export {
   InspectionAct,
   InspectionActStatus,
+  InspectionActUrgency,
+  InspectionDeadlineBasis,
+  InspectionDeadlineDayType,
 } from './inspection-act.entity';
 export { InspectionActAsset } from './inspection-act-asset.entity';
 export {
@@ -75,19 +45,13 @@ export {
   InspectionReportStatus,
   InspectionReportWordStatus,
 } from './inspection-report.entity';
-export {
-  InspectionActVersion,
-  InspectionActVersionEvent,
-} from './inspection-act-version.entity';
+export { InspectionActVersion, InspectionActVersionEvent } from './inspection-act-version.entity';
 export {
   InspectionActResponsible,
   InspectionResponsibleAttendanceStatus,
   InspectionResponsibleDocumentType,
 } from './inspection-act-responsible.entity';
-export {
-  InspectionActClosure,
-  InspectionActUploadMode,
-} from './inspection-act-closure.entity';
+export { InspectionActClosure, InspectionActUploadMode } from './inspection-act-closure.entity';
 export {
   InspectionActSignature,
   InspectionActSignatureSource,
@@ -95,21 +59,18 @@ export {
   InspectionActSignerType,
   InspectionCompanySignatureManifestation,
 } from './inspection-act-signature.entity';
+export { InspectionDeadlinePolicy } from './inspection-deadline-policy.entity';
+export { InspectionBusinessCalendarDay } from './inspection-business-calendar-day.entity';
+export { InspectionReportFollowUp, InspectionReportFollowUpType } from './inspection-report-follow-up.entity';
+export { SystemSmtpSettings, SmtpSecurityMode } from './system-smtp-settings.entity';
 export { FindingCategory } from './finding-category.entity';
 export { FindingCatalogItem } from './finding-catalog-item.entity';
 export { FindingCatalogItemAssetType } from './finding-catalog-item-asset-type.entity';
 export { FindingCatalogAssetTypeProfile } from './finding-catalog-asset-type-profile.entity';
 export { FindingCatalogAssetOverride } from './finding-catalog-asset-override.entity';
 export { FindingCatalogProposal, FindingCatalogProposalStatus } from './finding-catalog-proposal.entity';
-export {
-  InspectionFinding,
-  InspectionFindingResponseDueBasis,
-  InspectionFindingStatus,
-} from './inspection-finding.entity';
-export {
-  InspectionFindingVersion,
-  InspectionFindingVersionEvent,
-} from './inspection-finding-version.entity';
+export { InspectionFinding, InspectionFindingResponseDueBasis, InspectionFindingStatus } from './inspection-finding.entity';
+export { InspectionFindingVersion, InspectionFindingVersionEvent } from './inspection-finding-version.entity';
 export {
   InspectionCommunicationChannel,
   InspectionCommunicationDirection,
@@ -122,14 +83,8 @@ export {
   InspectionEvidenceSource,
   InspectionFindingEvidence,
 } from './inspection-finding-evidence.entity';
-export {
-  InspectionFindingVerificationVisit,
-  InspectionVerificationOutcome,
-} from './inspection-finding-verification-visit.entity';
-export {
-  InspectionFindingVerificationEvent,
-  InspectionFindingVerificationEventType,
-} from './inspection-finding-verification-event.entity';
+export { InspectionFindingVerificationVisit, InspectionVerificationOutcome } from './inspection-finding-verification-visit.entity';
+export { InspectionFindingVerificationEvent, InspectionFindingVerificationEventType } from './inspection-finding-verification-event.entity';
 
 import { AuditEvent } from './audit-event.entity';
 import { AuthSession } from './auth-session.entity';
@@ -170,6 +125,10 @@ import { InspectionActVersion } from './inspection-act-version.entity';
 import { InspectionActResponsible } from './inspection-act-responsible.entity';
 import { InspectionActClosure } from './inspection-act-closure.entity';
 import { InspectionActSignature } from './inspection-act-signature.entity';
+import { InspectionDeadlinePolicy } from './inspection-deadline-policy.entity';
+import { InspectionBusinessCalendarDay } from './inspection-business-calendar-day.entity';
+import { InspectionReportFollowUp } from './inspection-report-follow-up.entity';
+import { SystemSmtpSettings } from './system-smtp-settings.entity';
 import { FindingCategory } from './finding-category.entity';
 import { FindingCatalogItem } from './finding-catalog-item.entity';
 import { FindingCatalogItemAssetType } from './finding-catalog-item-asset-type.entity';
@@ -223,6 +182,10 @@ export const PHASE_A_ENTITIES = [
   InspectionActResponsible,
   InspectionActClosure,
   InspectionActSignature,
+  InspectionDeadlinePolicy,
+  InspectionBusinessCalendarDay,
+  InspectionReportFollowUp,
+  SystemSmtpSettings,
   FindingCategory,
   FindingCatalogItem,
   FindingCatalogItemAssetType,

From c97e5ae33c2845b4f4737f41c6e41e8f6545d2f8 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:45:29 -0300
Subject: [PATCH 009/224] feat(f4): add document workflow foundation migration

---
 ...0000000-f4-document-workflow-foundation.ts | 161 ++++++++++++++++++
 1 file changed, 161 insertions(+)
 create mode 100644 api-v3/src/database/migrations/1790000000000-f4-document-workflow-foundation.ts

diff --git a/api-v3/src/database/migrations/1790000000000-f4-document-workflow-foundation.ts b/api-v3/src/database/migrations/1790000000000-f4-document-workflow-foundation.ts
new file mode 100644
index 0000000..6eec43d
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000000000-f4-document-workflow-foundation.ts
@@ -0,0 +1,161 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class F4DocumentWorkflowFoundation1790000000000 implements MigrationInterface {
+  name = 'F4DocumentWorkflowFoundation1790000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE inspection_acts ALTER COLUMN code TYPE varchar(40)`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ALTER COLUMN code TYPE varchar(40)`);
+
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS urgency varchar(24) NOT NULL DEFAULT 'NON_URGENT'`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS deadline_days integer`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS deadline_day_type varchar(24)`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS deadline_basis varchar(24)`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS deadline_base_at timestamptz`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS deadline_at timestamptz`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS locked_at timestamptz`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS locked_by uuid`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS locked_sha256 char(64)`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS sealed_at timestamptz`);
+    await queryRunner.query(`ALTER TABLE inspection_acts ADD COLUMN IF NOT EXISTS sealed_by uuid`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_inspection_acts_deadline ON inspection_acts(deadline_at)`);
+
+    await queryRunner.query(`ALTER TABLE inspection_findings ADD COLUMN IF NOT EXISTS is_recurrence boolean NOT NULL DEFAULT false`);
+    await queryRunner.query(`ALTER TABLE inspection_findings ADD COLUMN IF NOT EXISTS recurrence_of_finding_id uuid`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_inspection_findings_recurrence_of ON inspection_findings(recurrence_of_finding_id)`);
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE inspection_findings
+          ADD CONSTRAINT fk_inspection_findings_recurrence_of
+          FOREIGN KEY (recurrence_of_finding_id) REFERENCES inspection_findings(id) ON DELETE RESTRICT;
+      EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+    `);
+
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS executive_summary text`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS report_description text`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS gedo_if_identifier varchar(255)`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS gedo_officialized_at timestamptz`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS gedo_pdf_original_name varchar(255)`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS gedo_pdf_stored_name varchar(255)`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS gedo_pdf_mime_type varchar(120)`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS gedo_pdf_size_bytes integer`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS gedo_pdf_sha256 char(64)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_inspection_reports_gedo_officialized_at ON inspection_reports(gedo_officialized_at)`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS inspection_deadline_policies (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        urgent_days integer NOT NULL DEFAULT 5 CHECK (urgent_days > 0),
+        urgent_day_type varchar(24) NOT NULL DEFAULT 'BUSINESS',
+        non_urgent_days integer NOT NULL DEFAULT 10 CHECK (non_urgent_days > 0),
+        non_urgent_day_type varchar(24) NOT NULL DEFAULT 'BUSINESS',
+        updated_by uuid,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        CONSTRAINT ck_inspection_deadline_policy_urgent_type CHECK (urgent_day_type IN ('BUSINESS','CALENDAR')),
+        CONSTRAINT ck_inspection_deadline_policy_non_urgent_type CHECK (non_urgent_day_type IN ('BUSINESS','CALENDAR'))
+      )
+    `);
+    await queryRunner.query(`
+      INSERT INTO inspection_deadline_policies (urgent_days, urgent_day_type, non_urgent_days, non_urgent_day_type)
+      SELECT 5, 'BUSINESS', 10, 'BUSINESS'
+      WHERE NOT EXISTS (SELECT 1 FROM inspection_deadline_policies)
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS inspection_business_calendar_days (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        date date NOT NULL,
+        is_business_day boolean NOT NULL DEFAULT false,
+        label varchar(200) NOT NULL,
+        updated_by uuid,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        CONSTRAINT uq_inspection_business_calendar_day UNIQUE(date)
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS inspection_report_follow_ups (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        report_id uuid NOT NULL,
+        type varchar(40) NOT NULL,
+        external_reference varchar(255),
+        occurred_at timestamptz NOT NULL,
+        description text,
+        original_name varchar(255),
+        stored_name varchar(255),
+        mime_type varchar(120),
+        size_bytes integer,
+        sha256 char(64),
+        created_by uuid,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        CONSTRAINT fk_inspection_report_follow_ups_report FOREIGN KEY(report_id) REFERENCES inspection_reports(id) ON DELETE CASCADE,
+        CONSTRAINT ck_inspection_report_follow_up_type CHECK (type IN ('COMPANY_NOTE','COMPANY_DOCUMENT','INTERNAL_NOTE','VERIFICATION','OTHER'))
+      )
+    `);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_inspection_report_follow_ups_report_created ON inspection_report_follow_ups(report_id, created_at)`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS system_smtp_settings (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        host varchar(255) NOT NULL,
+        port integer NOT NULL CHECK (port > 0 AND port <= 65535),
+        security_mode varchar(24) NOT NULL DEFAULT 'STARTTLS',
+        username varchar(255),
+        password_enc text,
+        from_name varchar(200) NOT NULL,
+        from_email varchar(320) NOT NULL,
+        reply_to varchar(320),
+        enabled boolean NOT NULL DEFAULT true,
+        updated_by uuid,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        CONSTRAINT ck_system_smtp_security_mode CHECK (security_mode IN ('NONE','STARTTLS','TLS'))
+      )
+    `);
+
+    await queryRunner.query(`
+      UPDATE inspection_acts
+      SET
+        deadline_days = COALESCE(deadline_days, 10),
+        deadline_day_type = COALESCE(deadline_day_type, 'BUSINESS'),
+        deadline_basis = COALESCE(deadline_basis, 'GEDO_DATE')
+      WHERE deadline_days IS NULL OR deadline_day_type IS NULL OR deadline_basis IS NULL
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS system_smtp_settings`);
+    await queryRunner.query(`DROP TABLE IF EXISTS inspection_report_follow_ups`);
+    await queryRunner.query(`DROP TABLE IF EXISTS inspection_business_calendar_days`);
+    await queryRunner.query(`DROP TABLE IF EXISTS inspection_deadline_policies`);
+
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS gedo_pdf_sha256`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS gedo_pdf_size_bytes`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS gedo_pdf_mime_type`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS gedo_pdf_stored_name`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS gedo_pdf_original_name`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS gedo_officialized_at`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS gedo_if_identifier`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS report_description`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS executive_summary`);
+
+    await queryRunner.query(`ALTER TABLE inspection_findings DROP CONSTRAINT IF EXISTS fk_inspection_findings_recurrence_of`);
+    await queryRunner.query(`ALTER TABLE inspection_findings DROP COLUMN IF EXISTS recurrence_of_finding_id`);
+    await queryRunner.query(`ALTER TABLE inspection_findings DROP COLUMN IF EXISTS is_recurrence`);
+
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS sealed_by`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS sealed_at`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS locked_sha256`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS locked_by`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS locked_at`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS deadline_at`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS deadline_base_at`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS deadline_basis`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS deadline_day_type`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS deadline_days`);
+    await queryRunner.query(`ALTER TABLE inspection_acts DROP COLUMN IF EXISTS urgency`);
+  }
+}

From d834bc7b827e0eb0c7442442b36d7aaed5889682 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:45:49 -0300
Subject: [PATCH 010/224] refactor(f4): remove Director report review circuit

---
 api-v3/src/inspection-reports/inspection-reports.module.ts | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-reports.module.ts b/api-v3/src/inspection-reports/inspection-reports.module.ts
index a997459..3ef820c 100644
--- a/api-v3/src/inspection-reports/inspection-reports.module.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.module.ts
@@ -3,8 +3,6 @@ import { AuditModule } from '../audit/audit.module';
 import { DocumentDeliveryController } from './document-delivery.controller';
 import { InspectionActPdfService } from './inspection-act-pdf.service';
 import { InspectionDocumentDeliveryService } from './inspection-document-delivery.service';
-import { InspectionReportReviewController, InspectionReportRevisionContentController } from './inspection-report-review.controller';
-import { InspectionReportReviewService } from './inspection-report-review.service';
 import { InspectionReportWordService } from './inspection-report-word.service';
 import { InspectionActReportController, InspectionReportsController } from './inspection-reports.controller';
 import { InspectionReportsService } from './inspection-reports.service';
@@ -16,8 +14,6 @@ import { SmtpDeliveryService } from './smtp-delivery.service';
     InspectionReportsController,
     InspectionActReportController,
     DocumentDeliveryController,
-    InspectionReportReviewController,
-    InspectionReportRevisionContentController,
   ],
   providers: [
     InspectionReportsService,
@@ -25,7 +21,6 @@ import { SmtpDeliveryService } from './smtp-delivery.service';
     InspectionActPdfService,
     InspectionDocumentDeliveryService,
     SmtpDeliveryService,
-    InspectionReportReviewService,
   ],
   exports: [InspectionReportsService],
 })

From f184c73c9e46ba4f0d4b9e310b95108d145279b1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:45:58 -0300
Subject: [PATCH 011/224] refactor(f4): remove Director report review endpoints

---
 .../inspection-report-review.controller.ts    | 87 -------------------
 1 file changed, 87 deletions(-)
 delete mode 100644 api-v3/src/inspection-reports/inspection-report-review.controller.ts

diff --git a/api-v3/src/inspection-reports/inspection-report-review.controller.ts b/api-v3/src/inspection-reports/inspection-report-review.controller.ts
deleted file mode 100644
index 0e397bd..0000000
--- a/api-v3/src/inspection-reports/inspection-report-review.controller.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { Body, Controller, Get, Param, ParseUUIDPipe, Post, Req, Res, UploadedFile, UseInterceptors } from '@nestjs/common';
-import { FileInterceptor } from '@nestjs/platform-express';
-import type { Response } from 'express';
-import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
-import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
-import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { ApproveInspectionReportDto } from './dto/approve-inspection-report.dto';
-import { CreateInspectionReportRevisionDto } from './dto/create-inspection-report-revision.dto';
-import { SignFinalInspectionReportDto } from './dto/sign-final-inspection-report.dto';
-import {
-  MAX_INSPECTION_REPORT_REVISION_BYTES,
-  type UploadedInspectionReportRevisionFile,
-} from './inspection-report-revision-file';
-import {
-  InspectionReportReviewService,
-  type InspectionReportReviewView,
-} from './inspection-report-review.service';
-
-@Controller('inspection-reports/:reportId/review')
-export class InspectionReportReviewController {
-  constructor(private readonly review: InspectionReportReviewService) {}
-
-  @Get()
-  @RequirePermissions('inspection_reports.read')
-  get(@Param('reportId', new ParseUUIDPipe({ version: '4' })) reportId: string): Promise<InspectionReportReviewView> {
-    return this.review.get(reportId);
-  }
-
-  @Post('revisions')
-  @RequirePermissions('inspection_reports.revise')
-  @UseInterceptors(FileInterceptor('file', { limits: { fileSize: MAX_INSPECTION_REPORT_REVISION_BYTES, files: 1 } }))
-  revision(
-    @Param('reportId', new ParseUUIDPipe({ version: '4' })) reportId: string,
-    @Body() dto: CreateInspectionReportRevisionDto,
-    @UploadedFile() file: UploadedInspectionReportRevisionFile | undefined,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ): Promise<InspectionReportReviewView> {
-    return this.review.createRevision(reportId, dto, file, principal, request);
-  }
-
-  @Post('approve')
-  @RequirePermissions('inspection_reports.review')
-  approve(
-    @Param('reportId', new ParseUUIDPipe({ version: '4' })) reportId: string,
-    @Body() dto: ApproveInspectionReportDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ): Promise<InspectionReportReviewView> {
-    return this.review.approve(reportId, dto, principal, request);
-  }
-
-  @Post('sign-final')
-  @RequirePermissions('inspection_reports.sign_final')
-  signFinal(
-    @Param('reportId', new ParseUUIDPipe({ version: '4' })) reportId: string,
-    @Body() dto: SignFinalInspectionReportDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ): Promise<InspectionReportReviewView> {
-    return this.review.signFinal(reportId, dto, principal, request);
-  }
-}
-
-@Controller('inspection-report-revisions')
-export class InspectionReportRevisionContentController {
-  constructor(private readonly review: InspectionReportReviewService) {}
-
-  @Get(':revisionId/content')
-  @RequirePermissions('inspection_reports.read')
-  async content(
-    @Param('revisionId', new ParseUUIDPipe({ version: '4' })) revisionId: string,
-    @Res() response: Response,
-  ): Promise<void> {
-    const content = await this.review.revisionContent(revisionId);
-    response.setHeader('Content-Type', content.mimeType);
-    response.setHeader('Content-Disposition', `attachment; filename="${content.originalName.replaceAll('"', '')}"`);
-    response.setHeader('Cache-Control', 'private, no-store');
-    response.setHeader('X-Content-Type-Options', 'nosniff');
-    await new Promise<void>((resolveSend, rejectSend) => {
-      response.sendFile(content.filePath, (error) => {
-        if (error) rejectSend(error);
-        else resolveSend();
-      });
-    });
-  }
-}

From c2d4f82a3a36711e221676423832e25e6a2001aa Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:46:03 -0300
Subject: [PATCH 012/224] refactor(f4): remove Director report review service

---
 .../inspection-report-review.service.ts       | 433 ------------------
 1 file changed, 433 deletions(-)
 delete mode 100644 api-v3/src/inspection-reports/inspection-report-review.service.ts

diff --git a/api-v3/src/inspection-reports/inspection-report-review.service.ts b/api-v3/src/inspection-reports/inspection-report-review.service.ts
deleted file mode 100644
index c1991fd..0000000
--- a/api-v3/src/inspection-reports/inspection-report-review.service.ts
+++ /dev/null
@@ -1,433 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { isAbsolute, parse, resolve } from 'node:path';
-import { ConflictException, ForbiddenException, Injectable, InternalServerErrorException, NotFoundException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { DataSource, EntityManager } from 'typeorm';
-import { administrationAuditContext } from '../administration/common/administration-audit';
-import { AuditService } from '../audit/audit.service';
-import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { AuditAction } from '../database/entities';
-import { sha256CanonicalJson } from '../inspection-closing/canonical-json';
-import type { ApproveInspectionReportDto } from './dto/approve-inspection-report.dto';
-import type { CreateInspectionReportRevisionDto } from './dto/create-inspection-report-revision.dto';
-import type { SignFinalInspectionReportDto } from './dto/sign-final-inspection-report.dto';
-import {
-  INSPECTION_REPORT_WORD_MIME,
-  inspectInspectionReportRevisionUpload,
-  type UploadedInspectionReportRevisionFile,
-  validateInspectionReportRevisionContainer,
-} from './inspection-report-revision-file';
-import { InspectionReportWordService } from './inspection-report-word.service';
-
-export type InspectionReportReviewStatus = 'PENDING_REVIEW' | 'APPROVED' | 'SIGNED';
-export type InspectionReportRevisionSource = 'AUTO' | 'DIRECTOR_UPLOAD';
-
-export interface InspectionReportReviewPerson {
-  id: string;
-  username: string;
-  firstName: string;
-  lastName: string;
-}
-
-export interface InspectionReportRevisionView {
-  id: string;
-  reportId: string;
-  revisionNumber: number;
-  source: InspectionReportRevisionSource;
-  originalName: string;
-  mimeType: string;
-  sizeBytes: number;
-  sha256: string;
-  changeSummary: string | null;
-  createdAt: Date;
-  createdBy: InspectionReportReviewPerson;
-}
-
-export interface InspectionReportSignatureView {
-  id: string;
-  revisionId: string;
-  signedAt: Date;
-  confirmationText: string;
-  signatureSha256: string;
-  signedBy: InspectionReportReviewPerson;
-}
-
-export interface InspectionReportReviewView {
-  reportId: string;
-  reportCode: string;
-  reviewStatus: InspectionReportReviewStatus;
-  currentRevisionNumber: number;
-  approvedRevisionId: string | null;
-  approvedAt: Date | null;
-  reviewNote: string | null;
-  approvedBy: InspectionReportReviewPerson | null;
-  signature: InspectionReportSignatureView | null;
-  revisions: InspectionReportRevisionView[];
-}
-
-interface LockedReport {
-  id: string;
-  code: string;
-  status: string;
-  frozenSha256: string;
-  reviewStatus: InspectionReportReviewStatus;
-  currentRevisionNumber: number;
-  approvedRevisionId: string | null;
-  approvedAt: Date | null;
-  reviewNote: string | null;
-}
-
-interface StoredRevisionRow {
-  id: string;
-  reportId: string;
-  revisionNumber: number;
-  source: InspectionReportRevisionSource;
-  originalName: string;
-  storedName: string;
-  mimeType: string;
-  sizeBytes: number;
-  sha256: string;
-}
-
-const FINAL_CONFIRMATION_TEXT = 'Confirmo que revisé la versión aprobada y firmo electrónicamente el informe final como Director de Hidrocarburos.';
-
-@Injectable()
-export class InspectionReportReviewService {
-  private readonly revisionRoot: string;
-
-  constructor(
-    private readonly dataSource: DataSource,
-    private readonly audit: AuditService,
-    private readonly word: InspectionReportWordService,
-    config: ConfigService,
-  ) {
-    const configured = config.get<string>('INSPECTION_REPORT_REVISION_ROOT') ?? '/app/storage/asset-media/inspection-report-revisions';
-    if (!isAbsolute(configured)) throw new Error('INSPECTION_REPORT_REVISION_ROOT must be an absolute path');
-    this.revisionRoot = resolve(configured);
-    if (this.revisionRoot === parse(this.revisionRoot).root) throw new Error('INSPECTION_REPORT_REVISION_ROOT cannot be the filesystem root');
-  }
-
-  async get(reportId: string): Promise<InspectionReportReviewView> {
-    await this.word.ensure(reportId);
-    await this.ensureAutomaticRevision(reportId);
-    return this.loadView(reportId);
-  }
-
-  async createRevision(
-    reportId: string,
-    dto: CreateInspectionReportRevisionDto,
-    file: UploadedInspectionReportRevisionFile | undefined,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InspectionReportReviewView> {
-    inspectInspectionReportRevisionUpload(file);
-    await this.assertDirector(principal.userId, this.dataSource.manager);
-    await mkdir(this.revisionRoot, { recursive: true, mode: 0o700 });
-    const storedName = `${reportId}-${randomUUID()}.docx`;
-    const filePath = resolve(this.revisionRoot, storedName);
-    if (!filePath.startsWith(`${this.revisionRoot}/`)) throw this.storageError();
-    await writeFile(filePath, file!.buffer, { mode: 0o600 });
-    try {
-      await validateInspectionReportRevisionContainer(filePath);
-      const sha256 = createHash('sha256').update(file!.buffer).digest('hex');
-      const created = await this.dataSource.transaction(async (manager) => {
-        const report = await this.lockReport(manager, reportId);
-        this.assertOpenForReview(report);
-        const nextRevision = report.currentRevisionNumber + 1;
-        const [row] = await manager.query(`
-          INSERT INTO inspection_report_revisions (
-            report_id, revision_number, source, original_name, stored_name, mime_type,
-            size_bytes, sha256, change_summary, created_by
-          ) VALUES ($1,$2,'DIRECTOR_UPLOAD',$3,$4,$5,$6,$7,$8,$9)
-          RETURNING id
-        `, [
-          report.id,
-          nextRevision,
-          this.cleanOriginalName(file!.originalname),
-          storedName,
-          INSPECTION_REPORT_WORD_MIME,
-          file!.buffer.length,
-          sha256,
-          dto.changeSummary.trim(),
-          principal.userId,
-        ]) as Array<{ id: string }>;
-        await manager.query(`
-          UPDATE inspection_reports
-          SET current_revision_number = $2, updated_at = CURRENT_TIMESTAMP
-          WHERE id = $1
-        `, [report.id, nextRevision]);
-        await this.audit.record({
-          ...administrationAuditContext(principal, request),
-          action: AuditAction.INSPECTION_REPORT_REVISION_ADDED,
-          entityType: 'inspection_report_revision',
-          entityId: row.id,
-          afterData: {
-            reportId: report.id,
-            reportCode: report.code,
-            revisionNumber: nextRevision,
-            sha256,
-            source: 'DIRECTOR_UPLOAD',
-          },
-        }, manager);
-        return row.id;
-      });
-      if (!created) throw this.storageError();
-    } catch (error) {
-      await rm(filePath, { force: true }).catch(() => undefined);
-      throw error;
-    }
-    return this.loadView(reportId);
-  }
-
-  async approve(
-    reportId: string,
-    dto: ApproveInspectionReportDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InspectionReportReviewView> {
-    await this.dataSource.transaction(async (manager) => {
-      await this.assertDirector(principal.userId, manager);
-      const report = await this.lockReport(manager, reportId);
-      this.assertOpenForReview(report);
-      const [revision] = await manager.query(`
-        SELECT id, revision_number AS "revisionNumber", sha256
-        FROM inspection_report_revisions
-        WHERE report_id = $1 AND revision_number = $2
-      `, [report.id, report.currentRevisionNumber]) as Array<{ id: string; revisionNumber: number; sha256: string }>;
-      if (!revision) throw new ConflictException({ code: 'INSPECTION_REPORT_REVISION_REQUIRED', message: 'El informe necesita una versión Word válida antes de aprobarse' });
-      const approvedAt = new Date();
-      await manager.query(`
-        UPDATE inspection_reports
-        SET review_status = 'APPROVED', approved_revision_id = $2, approved_by = $3,
-            approved_at = $4, review_note = $5, updated_at = CURRENT_TIMESTAMP
-        WHERE id = $1
-      `, [report.id, revision.id, principal.userId, approvedAt, dto.note?.trim() || null]);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_REPORT_APPROVED,
-        entityType: 'inspection_report',
-        entityId: report.id,
-        afterData: {
-          reportCode: report.code,
-          revisionId: revision.id,
-          revisionNumber: revision.revisionNumber,
-          revisionSha256: revision.sha256,
-          approvedAt: approvedAt.toISOString(),
-        },
-      }, manager);
-    });
-    return this.loadView(reportId);
-  }
-
-  async signFinal(
-    reportId: string,
-    dto: SignFinalInspectionReportDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InspectionReportReviewView> {
-    if (dto.confirmation !== true) throw new ConflictException({ code: 'INSPECTION_REPORT_SIGNATURE_CONFIRMATION_REQUIRED', message: 'Debés confirmar expresamente la firma final del informe' });
-    await this.dataSource.transaction(async (manager) => {
-      await this.assertDirector(principal.userId, manager);
-      const report = await this.lockReport(manager, reportId);
-      if (report.reviewStatus === 'SIGNED') throw new ConflictException({ code: 'INSPECTION_REPORT_ALREADY_SIGNED', message: 'El informe ya tiene una firma final inmutable' });
-      if (report.reviewStatus !== 'APPROVED' || !report.approvedRevisionId || !report.approvedAt) {
-        throw new ConflictException({ code: 'INSPECTION_REPORT_NOT_APPROVED', message: 'El Director debe aprobar una versión antes de firmar el informe final' });
-      }
-      const [revision] = await manager.query(`
-        SELECT id, revision_number AS "revisionNumber", sha256
-        FROM inspection_report_revisions
-        WHERE id = $1 AND report_id = $2
-      `, [report.approvedRevisionId, report.id]) as Array<{ id: string; revisionNumber: number; sha256: string }>;
-      if (!revision) throw new ConflictException({ code: 'INSPECTION_REPORT_APPROVED_REVISION_MISSING', message: 'La versión aprobada no está disponible para la firma final' });
-      const signedAt = new Date();
-      const payload = {
-        schemaVersion: 'DH-INSPECTION-REPORT-SIGNATURE-V1',
-        reportId: report.id,
-        reportCode: report.code,
-        reportFrozenSha256: report.frozenSha256,
-        revisionId: revision.id,
-        revisionNumber: revision.revisionNumber,
-        revisionSha256: revision.sha256,
-        signedBy: principal.userId,
-        signedByUsername: principal.username,
-        signedAt: signedAt.toISOString(),
-        confirmationText: FINAL_CONFIRMATION_TEXT,
-      };
-      const signatureSha256 = sha256CanonicalJson(payload);
-      const [signature] = await manager.query(`
-        INSERT INTO inspection_report_signatures (
-          report_id, revision_id, signed_by, signed_at, confirmation_text,
-          signature_payload, signature_sha256
-        ) VALUES ($1,$2,$3,$4,$5,$6,$7)
-        RETURNING id
-      `, [report.id, revision.id, principal.userId, signedAt, FINAL_CONFIRMATION_TEXT, payload, signatureSha256]) as Array<{ id: string }>;
-      await manager.query(`
-        UPDATE inspection_reports
-        SET review_status = 'SIGNED', signed_at = $2, updated_at = CURRENT_TIMESTAMP
-        WHERE id = $1
-      `, [report.id, signedAt]);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_REPORT_SIGNED,
-        entityType: 'inspection_report_signature',
-        entityId: signature.id,
-        afterData: {
-          reportId: report.id,
-          reportCode: report.code,
-          revisionId: revision.id,
-          revisionNumber: revision.revisionNumber,
-          revisionSha256: revision.sha256,
-          signatureSha256,
-          signedAt: signedAt.toISOString(),
-        },
-      }, manager);
-    });
-    return this.loadView(reportId);
-  }
-
-  async revisionContent(revisionId: string): Promise<{ filePath: string; originalName: string; mimeType: string }> {
-    const [revision] = await this.dataSource.query(`
-      SELECT id, report_id AS "reportId", revision_number AS "revisionNumber", source,
-             original_name AS "originalName", stored_name AS "storedName", mime_type AS "mimeType",
-             size_bytes::integer AS "sizeBytes", sha256
-      FROM inspection_report_revisions WHERE id = $1
-    `, [revisionId]) as StoredRevisionRow[];
-    if (!revision) throw new NotFoundException({ code: 'INSPECTION_REPORT_REVISION_NOT_FOUND', message: 'Versión del informe no encontrada' });
-    if (revision.source === 'AUTO') return this.word.content(revision.reportId);
-    const filePath = resolve(this.revisionRoot, revision.storedName);
-    if (!filePath.startsWith(`${this.revisionRoot}/`)) throw this.storageError();
-    const fileStat = await stat(filePath).catch(() => null);
-    if (!fileStat?.isFile() || fileStat.size !== revision.sizeBytes) throw this.storageError();
-    const buffer = await readFile(filePath);
-    const sha256 = createHash('sha256').update(buffer).digest('hex');
-    if (sha256 !== revision.sha256) throw this.storageError();
-    return { filePath, originalName: revision.originalName, mimeType: revision.mimeType };
-  }
-
-  private async ensureAutomaticRevision(reportId: string): Promise<void> {
-    await this.dataSource.query(`
-      INSERT INTO inspection_report_revisions (
-        report_id, revision_number, source, original_name, stored_name, mime_type,
-        size_bytes, sha256, change_summary, created_by, created_at
-      )
-      SELECT
-        id, 1, 'AUTO', word_original_name, word_stored_name, word_mime_type,
-        word_size_bytes, word_sha256, 'Versión automática inicial', generated_by,
-        COALESCE(word_generated_at, generated_at)
-      FROM inspection_reports
-      WHERE id = $1
-        AND word_status = 'READY'
-        AND word_original_name IS NOT NULL
-        AND word_stored_name IS NOT NULL
-        AND word_mime_type = $2
-        AND word_size_bytes > 0
-        AND word_sha256 ~ '^[0-9a-f]{64}$'
-      ON CONFLICT (report_id, revision_number) DO NOTHING
-    `, [reportId, INSPECTION_REPORT_WORD_MIME]);
-    await this.dataSource.query(`
-      UPDATE inspection_reports
-      SET current_revision_number = GREATEST(current_revision_number, 1), updated_at = CURRENT_TIMESTAMP
-      WHERE id = $1
-        AND EXISTS (SELECT 1 FROM inspection_report_revisions WHERE report_id = $1 AND revision_number = 1)
-    `, [reportId]);
-  }
-
-  private async loadView(reportId: string): Promise<InspectionReportReviewView> {
-    const [report] = await this.dataSource.query(`
-      SELECT
-        report.id AS "reportId",
-        report.code AS "reportCode",
-        report.review_status AS "reviewStatus",
-        report.current_revision_number AS "currentRevisionNumber",
-        report.approved_revision_id AS "approvedRevisionId",
-        report.approved_at AS "approvedAt",
-        report.review_note AS "reviewNote",
-        CASE WHEN approver.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', approver.id, 'username', approver.username, 'firstName', approver.first_name, 'lastName', approver.last_name
-        ) END AS "approvedBy"
-      FROM inspection_reports report
-      LEFT JOIN users approver ON approver.id = report.approved_by
-      WHERE report.id = $1
-    `, [reportId]) as Array<Omit<InspectionReportReviewView, 'signature' | 'revisions'>>;
-    if (!report) throw new NotFoundException({ code: 'INSPECTION_REPORT_NOT_FOUND', message: 'Informe de inspección no encontrado' });
-    const revisions = await this.dataSource.query(`
-      SELECT
-        revision.id,
-        revision.report_id AS "reportId",
-        revision.revision_number AS "revisionNumber",
-        revision.source,
-        revision.original_name AS "originalName",
-        revision.mime_type AS "mimeType",
-        revision.size_bytes::integer AS "sizeBytes",
-        revision.sha256,
-        revision.change_summary AS "changeSummary",
-        revision.created_at AS "createdAt",
-        JSONB_BUILD_OBJECT(
-          'id', creator.id, 'username', creator.username, 'firstName', creator.first_name, 'lastName', creator.last_name
-        ) AS "createdBy"
-      FROM inspection_report_revisions revision
-      JOIN users creator ON creator.id = revision.created_by
-      WHERE revision.report_id = $1
-      ORDER BY revision.revision_number DESC
-    `, [reportId]) as InspectionReportRevisionView[];
-    const [signature] = await this.dataSource.query(`
-      SELECT
-        signature.id,
-        signature.revision_id AS "revisionId",
-        signature.signed_at AS "signedAt",
-        signature.confirmation_text AS "confirmationText",
-        signature.signature_sha256 AS "signatureSha256",
-        JSONB_BUILD_OBJECT(
-          'id', signer.id, 'username', signer.username, 'firstName', signer.first_name, 'lastName', signer.last_name
-        ) AS "signedBy"
-      FROM inspection_report_signatures signature
-      JOIN users signer ON signer.id = signature.signed_by
-      WHERE signature.report_id = $1
-    `, [reportId]) as InspectionReportSignatureView[];
-    return { ...report, signature: signature ?? null, revisions };
-  }
-
-  private async lockReport(manager: EntityManager, reportId: string): Promise<LockedReport> {
-    const [report] = await manager.query(`
-      SELECT
-        id, code, status, frozen_sha256 AS "frozenSha256",
-        review_status AS "reviewStatus",
-        current_revision_number AS "currentRevisionNumber",
-        approved_revision_id AS "approvedRevisionId",
-        approved_at AS "approvedAt",
-        review_note AS "reviewNote"
-      FROM inspection_reports
-      WHERE id = $1
-      FOR UPDATE
-    `, [reportId]) as LockedReport[];
-    if (!report) throw new NotFoundException({ code: 'INSPECTION_REPORT_NOT_FOUND', message: 'Informe de inspección no encontrado' });
-    if (report.status !== 'FROZEN') throw new ConflictException({ code: 'INSPECTION_REPORT_NOT_REVIEWABLE', message: 'Sólo los informes congelados pueden ingresar al circuito de revisión' });
-    return report;
-  }
-
-  private assertOpenForReview(report: LockedReport): void {
-    if (report.reviewStatus === 'SIGNED') throw new ConflictException({ code: 'INSPECTION_REPORT_ALREADY_SIGNED', message: 'El informe firmado es definitivo y no admite nuevas versiones' });
-    if (report.reviewStatus === 'APPROVED') throw new ConflictException({ code: 'INSPECTION_REPORT_ALREADY_APPROVED', message: 'La versión ya fue aprobada y sólo resta la firma final del Director' });
-  }
-
-  private async assertDirector(userId: string, manager: EntityManager): Promise<void> {
-    const [role] = await manager.query(`
-      SELECT role.code
-      FROM user_roles membership
-      JOIN roles role ON role.id = membership.role_id
-      WHERE membership.user_id = $1 AND role.code = 'director'
-      LIMIT 1
-    `, [userId]) as Array<{ code: string }>;
-    if (!role) throw new ForbiddenException({ code: 'INSPECTION_REPORT_DIRECTOR_REQUIRED', message: 'Esta operación está reservada al Director de Hidrocarburos' });
-  }
-
-  private cleanOriginalName(value: string): string {
-    const cleaned = value.replace(/[\\/\0\r\n]/g, '_').trim();
-    return (cleaned || 'informe-corregido.docx').slice(0, 255);
-  }
-
-  private storageError(): InternalServerErrorException {
-    return new InternalServerErrorException({ code: 'INSPECTION_REPORT_REVISION_STORAGE_ERROR', message: 'La versión del informe no está disponible o no supera la validación de integridad' });
-  }
-}

From 6cc687d5e17fa0660ddaf1e5a2a21a8e7fc8d451 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:46:17 -0300
Subject: [PATCH 013/224] refactor(f4): remove survey runtime modules

---
 api-v3/src/app.module.ts | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/api-v3/src/app.module.ts b/api-v3/src/app.module.ts
index ed63e7f..6d0eacb 100644
--- a/api-v3/src/app.module.ts
+++ b/api-v3/src/app.module.ts
@@ -15,8 +15,6 @@ import { HealthController } from './health.controller';
 import { HealthService } from './health.service';
 import { DashboardModule } from './dashboard/dashboard.module';
 import { AssetMasterModule } from './asset-master/asset-master.module';
-import { SurveyPlanningModule } from './survey-planning/survey-planning.module';
-import { SurveyExecutionModule } from './survey-execution/survey-execution.module';
 import { InspectionVisitsModule } from './inspection-visits/inspection-visits.module';
 import { InspectionActsModule } from './inspection-acts/inspection-acts.module';
 import { InspectionFindingsModule } from './inspection-findings/inspection-findings.module';
@@ -69,8 +67,6 @@ function required(config: ConfigService, key: string): string {
     AdministrationModule,
     DashboardModule,
     AssetMasterModule,
-    SurveyPlanningModule,
-    SurveyExecutionModule,
     InspectionVisitsModule,
     InspectionActsModule,
     InspectionFindingsModule,

From 92240b21c2d7be99c41e31dbf63d473df286f7ea Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:47:33 -0300
Subject: [PATCH 014/224] feat(f4): adopt institutional INSP numbering

---
 .../inspection-visit-code.ts                  | 26 ++++++++++---------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/api-v3/src/inspection-visits/inspection-visit-code.ts b/api-v3/src/inspection-visits/inspection-visit-code.ts
index 3b48b52..fa946bd 100644
--- a/api-v3/src/inspection-visits/inspection-visit-code.ts
+++ b/api-v3/src/inspection-visits/inspection-visit-code.ts
@@ -4,12 +4,14 @@ export async function nextInspectionVisitCode(
   manager: EntityManager,
   plannedStartAt: Date,
 ): Promise<string> {
-  const [yearRow] = (await manager.query(`
-    SELECT EXTRACT(
-      YEAR FROM $1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza'
-    )::integer AS year
-  `, [plannedStartAt])) as Array<{ year: number }>;
-  const year = Number(yearRow?.year);
+  const [dateRow] = (await manager.query(`
+    SELECT
+      EXTRACT(YEAR FROM $1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::integer AS year,
+      TO_CHAR($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza', 'DD') AS day,
+      TO_CHAR($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza', 'MM') AS month,
+      TO_CHAR($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza', 'YY') AS short_year
+  `, [plannedStartAt])) as Array<{ year: number; day: string; month: string; short_year: string }>;
+  const year = Number(dateRow?.year);
   if (!Number.isInteger(year) || year < 2000 || year > 9999) {
     throw new Error('Unable to derive inspection visit year');
   }
@@ -20,15 +22,15 @@ export async function nextInspectionVisitCode(
   );
 
   const [sequenceRow] = (await manager.query(`
-    SELECT COALESCE(MAX(RIGHT(code, 6)::integer), 0)::integer AS sequence
+    SELECT COALESCE(MAX(SUBSTRING(code FROM 6 FOR 5)::integer), 0)::integer AS sequence
     FROM inspection_visits
-    WHERE code LIKE $1
-      AND code ~ ('^INS-' || $2::text || '-[0-9]{6}$')
-  `, [`INS-${year}-%`, year])) as Array<{ sequence: number }>;
+    WHERE code ~ '^INSP-[0-9]{5}-[0-9]{2}-[0-9]{2}-[0-9]{2}$'
+      AND RIGHT(code, 2) = $1
+  `, [dateRow.short_year])) as Array<{ sequence: number }>;
 
   const sequence = Number(sequenceRow?.sequence ?? 0) + 1;
-  if (sequence > 999999) {
+  if (sequence > 99999) {
     throw new Error(`Inspection visit sequence exhausted for ${year}`);
   }
-  return `INS-${year}-${String(sequence).padStart(6, '0')}`;
+  return `INSP-${String(sequence).padStart(5, '0')}-${dateRow.day}-${dateRow.month}-${dateRow.short_year}`;
 }

From bda4ce224d3c5f78b2ad8b2d8c1db23d27ffda65 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:49:41 -0300
Subject: [PATCH 015/224] feat(f4): require explicit act urgency

---
 api-v3/src/inspection-acts/dto/create-inspection-act.dto.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/api-v3/src/inspection-acts/dto/create-inspection-act.dto.ts b/api-v3/src/inspection-acts/dto/create-inspection-act.dto.ts
index 5ba1ee7..62c9566 100644
--- a/api-v3/src/inspection-acts/dto/create-inspection-act.dto.ts
+++ b/api-v3/src/inspection-acts/dto/create-inspection-act.dto.ts
@@ -4,6 +4,7 @@ import {
   ArrayMinSize,
   ArrayUnique,
   IsArray,
+  IsEnum,
   IsISO8601,
   IsOptional,
   IsString,
@@ -11,11 +12,15 @@ import {
   MaxLength,
   MinLength,
 } from 'class-validator';
+import { InspectionActUrgency } from '../../database/entities';
 
 export class CreateInspectionActDto {
   @IsISO8601({ strict: true })
   occurredAt!: string;
 
+  @IsEnum(InspectionActUrgency)
+  urgency!: InspectionActUrgency;
+
   @Transform(({ value }) => (typeof value === 'string' ? value.trim() : value))
   @IsString()
   @MinLength(1)

From 01efa2a8cc6e61801db164200348260de4fae0e1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:49:49 -0300
Subject: [PATCH 016/224] feat(f4): allow act urgency update while draft

---
 api-v3/src/inspection-acts/dto/update-inspection-act.dto.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/api-v3/src/inspection-acts/dto/update-inspection-act.dto.ts b/api-v3/src/inspection-acts/dto/update-inspection-act.dto.ts
index 7a780aa..af2be32 100644
--- a/api-v3/src/inspection-acts/dto/update-inspection-act.dto.ts
+++ b/api-v3/src/inspection-acts/dto/update-inspection-act.dto.ts
@@ -4,6 +4,7 @@ import {
   ArrayMinSize,
   ArrayUnique,
   IsArray,
+  IsEnum,
   IsISO8601,
   IsOptional,
   IsString,
@@ -11,12 +12,17 @@ import {
   MaxLength,
   MinLength,
 } from 'class-validator';
+import { InspectionActUrgency } from '../../database/entities';
 
 export class UpdateInspectionActDto {
   @IsOptional()
   @IsISO8601({ strict: true })
   occurredAt?: string;
 
+  @IsOptional()
+  @IsEnum(InspectionActUrgency)
+  urgency?: InspectionActUrgency;
+
   @IsOptional()
   @Transform(({ value }) => (typeof value === 'string' ? value.trim() : value))
   @IsString()

From e7a9ff7dd9a31759106db41abef2326c9b12d2bc Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:51:11 -0300
Subject: [PATCH 017/224] feat(f4): align act numbering and urgency contract

---
 .../inspection-acts.service.ts                | 66 +++++++++++++++++--
 1 file changed, 62 insertions(+), 4 deletions(-)

diff --git a/api-v3/src/inspection-acts/inspection-acts.service.ts b/api-v3/src/inspection-acts/inspection-acts.service.ts
index 5d89a31..260f858 100644
--- a/api-v3/src/inspection-acts/inspection-acts.service.ts
+++ b/api-v3/src/inspection-acts/inspection-acts.service.ts
@@ -14,6 +14,9 @@ import {
   DocumentSequenceType,
   InspectionAct,
   InspectionActStatus,
+  InspectionActUrgency,
+  InspectionDeadlineBasis,
+  InspectionDeadlineDayType,
   InspectionActVersionEvent,
   InspectionVisit,
   InspectionVisitStatus,
@@ -72,6 +75,17 @@ export interface InspectionActListItem {
   title: string;
   summary: string;
   observations: string | null;
+  urgency: InspectionActUrgency;
+  deadlineDays: number | null;
+  deadlineDayType: InspectionDeadlineDayType | null;
+  deadlineBasis: InspectionDeadlineBasis | null;
+  deadlineBaseAt: Date | null;
+  deadlineAt: Date | null;
+  lockedAt: Date | null;
+  lockedBy: string | null;
+  lockedSha256: string | null;
+  sealedAt: Date | null;
+  sealedBy: string | null;
   currentVersion: number;
   cancellationReason: string | null;
   closedAt: Date | null;
@@ -313,13 +327,16 @@ export class InspectionActsService {
       const occurredAt = new Date(dto.occurredAt);
       const actYear = await this.yearAtProjectTimezone(manager, occurredAt);
       const actNumber = await this.allocateNumber(manager, actYear);
-      if (actNumber > 999999) {
+      if (actNumber > 99999) {
         throw new ConflictException({
           code: 'INSPECTION_ACT_SEQUENCE_EXHAUSTED',
           message: 'La numeración anual de actas agotó su rango disponible',
         });
       }
-      const code = `ACTA-${actYear}-${String(actNumber).padStart(6, '0')}`;
+      const [dateRow] = (await manager.query(`
+        SELECT TO_CHAR($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza', 'DD-MM-YY') AS date_part
+      `, [occurredAt])) as Array<{ date_part: string }>;
+      const code = `ACT-${String(actNumber).padStart(5, '0')}-${dateRow.date_part}`;
       const act = manager.getRepository(InspectionAct).create({
         visitId,
         actYear,
@@ -330,6 +347,17 @@ export class InspectionActsService {
         title: dto.title,
         summary: dto.summary,
         observations: dto.observations ?? null,
+        urgency: dto.urgency,
+        deadlineDays: null,
+        deadlineDayType: null,
+        deadlineBasis: null,
+        deadlineBaseAt: null,
+        deadlineAt: null,
+        lockedAt: null,
+        lockedBy: null,
+        lockedSha256: null,
+        sealedAt: null,
+        sealedBy: null,
         currentVersion: 0,
         cancellationReason: null,
         createdBy: principal.userId,
@@ -384,6 +412,7 @@ export class InspectionActsService {
       await this.assertVisitAssets(manager, visit.id, nextAssetIds);
       const before = await this.loadView(manager, id);
       if (dto.occurredAt !== undefined) act.occurredAt = nextOccurredAt;
+      if (dto.urgency !== undefined) act.urgency = dto.urgency;
       if (dto.title !== undefined) act.title = dto.title;
       if (dto.summary !== undefined) act.summary = dto.summary;
       if (dto.observations !== undefined) act.observations = dto.observations;
@@ -474,6 +503,17 @@ export class InspectionActsService {
         act.title,
         act.summary,
         act.observations,
+        act.urgency,
+        act.deadline_days AS "deadlineDays",
+        act.deadline_day_type AS "deadlineDayType",
+        act.deadline_basis AS "deadlineBasis",
+        act.deadline_base_at AS "deadlineBaseAt",
+        act.deadline_at AS "deadlineAt",
+        act.locked_at AS "lockedAt",
+        act.locked_by AS "lockedBy",
+        act.locked_sha256 AS "lockedSha256",
+        act.sealed_at AS "sealedAt",
+        act.sealed_by AS "sealedBy",
         act.current_version AS "currentVersion",
         act.cancellation_reason AS "cancellationReason",
         act.closed_at AS "closedAt",
@@ -645,7 +685,7 @@ export class InspectionActsService {
     if (rows.length > 0) {
       throw new ConflictException({
         code: 'INSPECTION_VISIT_DRAFT_ACT_ALREADY_EXISTS',
-        message: 'La inspección ya tiene un acta en borrador; preparala o cancelala antes de crear otra',
+        message: 'La inspección ya tiene un acta en borrador; finalizala o cancelala antes de crear otra',
       });
     }
   }
@@ -665,7 +705,7 @@ export class InspectionActsService {
     if (assetIds.length < 1 || Number(row?.count ?? 0) !== assetIds.length) {
       throw new BadRequestException({
         code: 'INSPECTION_ACT_ASSET_INVALID',
-        message: 'Cada activo del acta debe estar incluido en la visita',
+        message: 'Cada inventario del acta debe estar incluido en la inspección',
       });
     }
   }
@@ -758,6 +798,15 @@ export class InspectionActsService {
         'title', act.title,
         'summary', act.summary,
         'observations', act.observations,
+        'urgency', act.urgency,
+        'deadlineDays', act.deadline_days,
+        'deadlineDayType', act.deadline_day_type,
+        'deadlineBasis', act.deadline_basis,
+        'deadlineBaseAt', act.deadline_base_at,
+        'deadlineAt', act.deadline_at,
+        'lockedAt', act.locked_at,
+        'lockedSha256', act.locked_sha256,
+        'sealedAt', act.sealed_at,
         'currentVersion', act.current_version,
         'cancellationReason', act.cancellation_reason,
         'createdBy', act.created_by,
@@ -804,6 +853,15 @@ export class InspectionActsService {
       title: act.title,
       summary: act.summary,
       observations: act.observations,
+      urgency: act.urgency,
+      deadlineDays: act.deadlineDays,
+      deadlineDayType: act.deadlineDayType,
+      deadlineBasis: act.deadlineBasis,
+      deadlineBaseAt: act.deadlineBaseAt,
+      deadlineAt: act.deadlineAt,
+      lockedAt: act.lockedAt,
+      lockedSha256: act.lockedSha256,
+      sealedAt: act.sealedAt,
       currentVersion: act.currentVersion,
       cancellationReason: act.cancellationReason,
       closedAt: act.closedAt,

From 56f9c4234beb2bd0db60d300e71b997a5dd5b5b0 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:52:29 -0300
Subject: [PATCH 018/224] feat(f4): add locked and sealed act version events

---
 api-v3/src/database/entities/inspection-act-version.entity.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/api-v3/src/database/entities/inspection-act-version.entity.ts b/api-v3/src/database/entities/inspection-act-version.entity.ts
index ba98320..5c72100 100644
--- a/api-v3/src/database/entities/inspection-act-version.entity.ts
+++ b/api-v3/src/database/entities/inspection-act-version.entity.ts
@@ -3,6 +3,8 @@ import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
 export enum InspectionActVersionEvent {
   CREATED = 'CREATED',
   UPDATED = 'UPDATED',
+  LOCKED = 'LOCKED',
+  SEALED = 'SEALED',
   READY = 'READY',
   REOPENED = 'REOPENED',
   CLOSED = 'CLOSED',

From c348f3162c987a7e516978b2f2d7534d9c3d9b09 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:52:58 -0300
Subject: [PATCH 019/224] feat(f4): add lifecycle and document audit actions

---
 api-v3/src/database/entities/audit-event.entity.ts | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/api-v3/src/database/entities/audit-event.entity.ts b/api-v3/src/database/entities/audit-event.entity.ts
index f77d9b2..6fabafe 100644
--- a/api-v3/src/database/entities/audit-event.entity.ts
+++ b/api-v3/src/database/entities/audit-event.entity.ts
@@ -82,15 +82,24 @@ export enum AuditAction {
   INSPECTION_ACT_UPDATED = 'INSPECTION_ACT_UPDATED',
   INSPECTION_ACT_CANCELLED = 'INSPECTION_ACT_CANCELLED',
   INSPECTION_ACT_RESPONSIBLE_UPDATED = 'INSPECTION_ACT_RESPONSIBLE_UPDATED',
+  INSPECTION_ACT_LOCKED = 'INSPECTION_ACT_LOCKED',
+  INSPECTION_ACT_SEALED = 'INSPECTION_ACT_SEALED',
   INSPECTION_ACT_READY = 'INSPECTION_ACT_READY',
   INSPECTION_ACT_REOPENED = 'INSPECTION_ACT_REOPENED',
   INSPECTION_ACT_SIGNATURE_RECORDED = 'INSPECTION_ACT_SIGNATURE_RECORDED',
   INSPECTION_ACT_COMPANY_OUTCOME_RECORDED = 'INSPECTION_ACT_COMPANY_OUTCOME_RECORDED',
   INSPECTION_ACT_CLOSED = 'INSPECTION_ACT_CLOSED',
   INSPECTION_REPORT_GENERATED = 'INSPECTION_REPORT_GENERATED',
+  INSPECTION_REPORT_UPDATED = 'INSPECTION_REPORT_UPDATED',
   INSPECTION_REPORT_REVISION_ADDED = 'INSPECTION_REPORT_REVISION_ADDED',
+  INSPECTION_REPORT_OFFICIALIZED = 'INSPECTION_REPORT_OFFICIALIZED',
+  INSPECTION_REPORT_FOLLOW_UP_ADDED = 'INSPECTION_REPORT_FOLLOW_UP_ADDED',
   INSPECTION_REPORT_APPROVED = 'INSPECTION_REPORT_APPROVED',
   INSPECTION_REPORT_SIGNED = 'INSPECTION_REPORT_SIGNED',
+  INSPECTION_DEADLINE_POLICY_UPDATED = 'INSPECTION_DEADLINE_POLICY_UPDATED',
+  INSPECTION_BUSINESS_CALENDAR_UPDATED = 'INSPECTION_BUSINESS_CALENDAR_UPDATED',
+  SMTP_SETTINGS_UPDATED = 'SMTP_SETTINGS_UPDATED',
+  SMTP_TEST_SENT = 'SMTP_TEST_SENT',
   DOCUMENT_DELIVERY_SETTINGS_UPDATED = 'DOCUMENT_DELIVERY_SETTINGS_UPDATED',
   DOCUMENT_DELIVERY_RETRY_REQUESTED = 'DOCUMENT_DELIVERY_RETRY_REQUESTED',
   DOCUMENT_DELIVERY_SENT = 'DOCUMENT_DELIVERY_SENT',

From f23a28e4380d36f1ec3b872d351206909966778e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:54:53 -0300
Subject: [PATCH 020/224] refactor(f4): replace READY/CLOSED lifecycle with
 LOCKED/SEALED

---
 .../inspection-closing.service.ts             | 1093 +++++++----------
 1 file changed, 454 insertions(+), 639 deletions(-)

diff --git a/api-v3/src/inspection-closing/inspection-closing.service.ts b/api-v3/src/inspection-closing/inspection-closing.service.ts
index be3c131..8953f74 100644
--- a/api-v3/src/inspection-closing/inspection-closing.service.ts
+++ b/api-v3/src/inspection-closing/inspection-closing.service.ts
@@ -14,7 +14,6 @@ import { DataSource, EntityManager } from 'typeorm';
 import { administrationAuditContext } from '../administration/common/administration-audit';
 import { AuditService } from '../audit/audit.service';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
 import {
   AuditAction,
   InspectionAct,
@@ -23,28 +22,32 @@ import {
   InspectionActSignerType,
   InspectionCompanySignatureManifestation,
   InspectionActStatus,
+  InspectionActUrgency,
+  InspectionDeadlineBasis,
+  InspectionDeadlineDayType,
   InspectionActUploadMode,
   InspectionActVersionEvent,
   InspectionResponsibleAttendanceStatus,
   InspectionVisit,
   InspectionVisitStatus,
 } from '../database/entities';
+import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
+import { InspectionReportsService } from '../inspection-reports/inspection-reports.service';
 import { sha256CanonicalJson } from './canonical-json';
 import type { CloseInspectionActDto } from './dto/close-inspection-act.dto';
-import { InspectionReportsService } from '../inspection-reports/inspection-reports.service';
 import type { CreateCompanyOutcomeDto } from './dto/create-company-outcome.dto';
-import type { CreateInspectionSignatureDto } from './dto/create-inspection-signature.dto';
 import type { CreateCompanySignatureDto } from './dto/create-company-signature.dto';
+import type { CreateInspectionSignatureDto } from './dto/create-inspection-signature.dto';
 import type { UpsertInspectionResponsibleDto } from './dto/upsert-inspection-responsible.dto';
 import {
   inspectInspectionSignatureFile,
   type UploadedInspectionSignatureFile,
 } from './inspection-signature-file';
 
-const CLOSURE_SCHEMA_VERSION = 'DH-ACT-CLOSURE-V2';
-const CONSENT_VERSION = 'D5-1';
-const INSPECTOR_CONSENT = 'Declaro que esta firma manuscrita fue realizada por mí y se incorpora al acta como constancia de mi intervención y conformidad con su contenido.';
-const COMPANY_CONSENT = 'Declaro haber leído o recibido explicación del contenido del acta y que esta firma manuscrita se incorpora como constancia de recepción, sin implicar aceptación de los hallazgos.';
+const CLOSURE_SCHEMA_VERSION = 'DH-ACT-LIFECYCLE-V4';
+const CONSENT_VERSION = 'F4-1';
+const INSPECTOR_CONSENT = 'Declaro que revisé el contenido del acta bloqueada y que esta firma deja constancia de mi intervención como inspector/a.';
+const COMPANY_CONSENT = 'Declaro haber accedido al contenido íntegro del acta bloqueada y que esta firma electrónica deja constancia de mi recepción y manifestación, sin alterar el contenido del acta.';
 
 interface ResponsibleView {
   actId: string;
@@ -114,12 +117,28 @@ interface ClosureRecord {
   closedBy: string | null;
 }
 
+interface DeadlinePolicy {
+  urgentDays: number;
+  urgentDayType: InspectionDeadlineDayType;
+  nonUrgentDays: number;
+  nonUrgentDayType: InspectionDeadlineDayType;
+}
+
 export interface InspectionClosureView {
   act: {
     id: string;
     code: string;
     status: InspectionActStatus;
     visitId: string;
+    urgency: InspectionActUrgency;
+    deadlineDays: number | null;
+    deadlineDayType: InspectionDeadlineDayType | null;
+    deadlineBasis: InspectionDeadlineBasis | null;
+    deadlineBaseAt: Date | null;
+    deadlineAt: Date | null;
+    lockedAt: Date | null;
+    lockedSha256: string | null;
+    sealedAt: Date | null;
     currentVersion: number;
     closedAt: Date | null;
     closedBy: string | null;
@@ -208,17 +227,18 @@ export class InspectionClosingService {
         INSERT INTO inspection_act_responsibles (
           act_id, attendance_status, full_name, document_type, document_number,
           position, email, phone, absence_reason, updated_by
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+        ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
         ON CONFLICT (act_id) DO UPDATE SET
-          attendance_status = EXCLUDED.attendance_status,
-          full_name = EXCLUDED.full_name,
-          document_type = EXCLUDED.document_type,
-          document_number = EXCLUDED.document_number,
-          position = EXCLUDED.position,
-          email = EXCLUDED.email,
-          phone = EXCLUDED.phone,
-          absence_reason = EXCLUDED.absence_reason,
-          updated_by = EXCLUDED.updated_by
+          attendance_status=EXCLUDED.attendance_status,
+          full_name=EXCLUDED.full_name,
+          document_type=EXCLUDED.document_type,
+          document_number=EXCLUDED.document_number,
+          position=EXCLUDED.position,
+          email=EXCLUDED.email,
+          phone=EXCLUDED.phone,
+          absence_reason=EXCLUDED.absence_reason,
+          updated_by=EXCLUDED.updated_by,
+          updated_at=CURRENT_TIMESTAMP
       `, [
         actId,
         dto.attendanceStatus,
@@ -239,12 +259,13 @@ export class InspectionClosingService {
         entityId: actId,
         beforeData: before as unknown as Record<string, unknown> | null,
         afterData: after as unknown as Record<string, unknown>,
-        metadata: { actId, visitId: visit.id },
+        metadata: { actId, inspectionId: visit.id },
       }, manager);
       return this.loadView(manager, actId);
     });
   }
 
+  /** Finaliza el contenido: desde este punto el Acta queda inmutable. */
   async prepare(
     actId: string,
     principal: AuthPrincipal,
@@ -256,157 +277,127 @@ export class InspectionClosingService {
       this.assertDraftInProgress(act, visit);
       await this.assertActorAssigned(manager, visit.id, principal, true);
       await this.requireResponsible(manager, actId);
-      const [count] = (await manager.query(`
-        SELECT COUNT(*)::integer AS total
-        FROM inspection_findings
-        WHERE act_id = $1 AND status <> 'VOIDED'
-      `, [actId])) as Array<{ total: number }>;
-      const [verification] = (await manager.query(`
-        SELECT
-          COUNT(*)::integer AS total,
-          COUNT(*) FILTER (WHERE verification_link.outcome IS NOT NULL)::integer AS completed
-        FROM inspection_finding_verification_visits verification_link
-        WHERE verification_link.visit_id = $1
-      `, [visit.id])) as Array<{ total: number; completed: number }>;
-      const verificationTotal = Number(verification?.total ?? 0);
-      const verificationCompleted = Number(verification?.completed ?? 0);
-      if (verificationTotal > 0 && verificationCompleted !== verificationTotal) {
-        throw new ConflictException({
-          code: 'INSPECTION_VERIFICATION_RESULTS_REQUIRED',
-          message: 'Registrá el resultado de todos los hallazgos a verificar antes de preparar el acta',
-        });
-      }
-      if (Number(count?.total ?? 0) < 1 && verificationTotal < 1) {
-        throw new ConflictException({
-          code: 'INSPECTION_ACT_FINDING_REQUIRED',
-          message: 'El acta debe contener al menos un hallazgo o una verificación registrada antes de prepararse',
-        });
-      }
-      const signatures = await this.signatureCount(manager, actId);
-      if (signatures > 0) {
+      await this.assertVerificationResultsComplete(manager, visit.id);
+      if (await this.signatureCount(manager, actId)) {
         throw new ConflictException({
           code: 'INSPECTION_ACT_ALREADY_SIGNED',
-          message: 'El acta ya tiene firmas y no puede volver a prepararse',
+          message: 'El acta ya tiene constancias de firma y no puede volver a finalizarse',
         });
       }
+
+      const policy = await this.deadlinePolicy(manager);
+      const deadlineDays = act.urgency === InspectionActUrgency.URGENT
+        ? policy.urgentDays
+        : policy.nonUrgentDays;
+      const deadlineDayType = act.urgency === InspectionActUrgency.URGENT
+        ? policy.urgentDayType
+        : policy.nonUrgentDayType;
+      const deadlineBasis = act.urgency === InspectionActUrgency.URGENT
+        ? InspectionDeadlineBasis.ACT_DATE
+        : InspectionDeadlineBasis.GEDO_DATE;
+      const deadlineBaseAt = act.urgency === InspectionActUrgency.URGENT
+        ? act.occurredAt
+        : null;
+      const deadlineAt = deadlineBaseAt
+        ? await this.calculateDeadline(manager, deadlineBaseAt, deadlineDays, deadlineDayType)
+        : null;
+      const lockedAt = new Date();
+
       const [updated] = (await manager.query(`
         UPDATE inspection_acts
-        SET status = 'READY',
-            current_version = current_version + 1,
-            updated_by = $2,
-            updated_at = CURRENT_TIMESTAMP
-        WHERE id = $1
+        SET status='LOCKED',
+            deadline_days=$2,
+            deadline_day_type=$3,
+            deadline_basis=$4,
+            deadline_base_at=$5,
+            deadline_at=$6,
+            locked_at=$7,
+            locked_by=$8,
+            current_version=current_version+1,
+            updated_by=$8,
+            updated_at=$7
+        WHERE id=$1
         RETURNING current_version AS "versionNumber"
-      `, [actId, principal.userId])) as Array<{ versionNumber: number }>;
-      const preparedAt = new Date();
-      const preparedSnapshot = await this.buildPreparedSnapshot(manager, actId, preparedAt);
-      const preparedSha256 = sha256CanonicalJson(preparedSnapshot);
-      await manager.query(`
-        INSERT INTO inspection_act_closures (
-          act_id, schema_version, prepared_snapshot, prepared_sha256,
-          prepared_at, prepared_by
-        ) VALUES ($1, $2, $3, $4, $5, $6)
-        ON CONFLICT (act_id) DO UPDATE SET
-          schema_version = EXCLUDED.schema_version,
-          prepared_snapshot = EXCLUDED.prepared_snapshot,
-          prepared_sha256 = EXCLUDED.prepared_sha256,
-          prepared_at = EXCLUDED.prepared_at,
-          prepared_by = EXCLUDED.prepared_by
       `, [
         actId,
-        CLOSURE_SCHEMA_VERSION,
-        preparedSnapshot,
-        preparedSha256,
-        preparedAt,
+        deadlineDays,
+        deadlineDayType,
+        deadlineBasis,
+        deadlineBaseAt,
+        deadlineAt,
+        lockedAt,
         principal.userId,
-      ]);
+      ])) as Array<{ versionNumber: number }>;
+
+      const preparedSnapshot = await this.buildLockedSnapshot(manager, actId, lockedAt);
+      const preparedSha256 = sha256CanonicalJson(preparedSnapshot);
+      await manager.query(`
+        UPDATE inspection_acts
+        SET locked_sha256=$2
+        WHERE id=$1
+      `, [actId, preparedSha256]);
+      await manager.query(`
+        INSERT INTO inspection_act_closures (
+          act_id,schema_version,prepared_snapshot,prepared_sha256,prepared_at,prepared_by
+        ) VALUES ($1,$2,$3,$4,$5,$6)
+        ON CONFLICT (act_id) DO UPDATE SET
+          schema_version=EXCLUDED.schema_version,
+          prepared_snapshot=EXCLUDED.prepared_snapshot,
+          prepared_sha256=EXCLUDED.prepared_sha256,
+          prepared_at=EXCLUDED.prepared_at,
+          prepared_by=EXCLUDED.prepared_by,
+          final_snapshot=NULL,
+          final_sha256=NULL,
+          device_closed_at=NULL,
+          server_closed_at=NULL,
+          upload_mode=NULL,
+          closed_by=NULL
+      `, [actId, CLOSURE_SCHEMA_VERSION, preparedSnapshot, preparedSha256, lockedAt, principal.userId]);
       await manager.query(`
         INSERT INTO inspection_act_versions (
-          act_id, version_number, event, snapshot, actor_user_id, actor_username
-        ) VALUES ($1, $2, $3, $4, $5, $6)
+          act_id,version_number,event,snapshot,actor_user_id,actor_username
+        ) VALUES ($1,$2,$3,$4,$5,$6)
       `, [
         actId,
         Number(updated.versionNumber),
-        InspectionActVersionEvent.READY,
+        InspectionActVersionEvent.LOCKED,
         preparedSnapshot,
         principal.userId,
         principal.username,
       ]);
       await this.audit.record({
         ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_ACT_READY,
+        action: AuditAction.INSPECTION_ACT_LOCKED,
         entityType: 'inspection_act',
         entityId: actId,
         afterData: {
-          status: InspectionActStatus.READY,
-          preparedSha256,
-          schemaVersion: CLOSURE_SCHEMA_VERSION,
+          status: InspectionActStatus.LOCKED,
+          lockedSha256: preparedSha256,
+          urgency: act.urgency,
+          deadlineDays,
+          deadlineDayType,
+          deadlineBasis,
+          deadlineBaseAt,
+          deadlineAt,
         },
-        metadata: { actId, visitId: visit.id, versionNumber: Number(updated.versionNumber) },
+        metadata: { actId, inspectionId: visit.id, versionNumber: Number(updated.versionNumber) },
       }, manager);
       return this.loadView(manager, actId);
     });
   }
 
+  /**
+   * F4 elimina la reapertura normal: Finalizar Acta significa inmovilizar su contenido.
+   * Una eventual rectificación administrativa debe ser otro acto auditado, no volver a DRAFT.
+   */
   async reopen(
-    actId: string,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
+    _actId: string,
+    _principal: AuthPrincipal,
+    _request: RequestWithContext,
   ): Promise<InspectionClosureView> {
-    assertMobileInspector(principal);
-    return this.dataSource.transaction(async (manager) => {
-      const { act, visit } = await this.lockContext(manager, actId);
-      if (act.status !== InspectionActStatus.READY || visit.status !== InspectionVisitStatus.IN_PROGRESS) {
-        throw new ConflictException({
-          code: 'INSPECTION_ACT_NOT_READY',
-          message: 'Sólo puede reabrirse un acta preparada de una visita en curso',
-        });
-      }
-      await this.assertActorAssigned(manager, visit.id, principal, true);
-      if (await this.signatureCount(manager, actId)) {
-        throw new ConflictException({
-          code: 'INSPECTION_ACT_SIGNED_CANNOT_REOPEN',
-          message: 'El acta ya tiene firmas y no puede volver a borrador',
-        });
-      }
-      const closure = await this.requireClosure(manager, actId);
-      const [updated] = (await manager.query(`
-        UPDATE inspection_acts
-        SET status = 'DRAFT',
-            current_version = current_version + 1,
-            updated_by = $2,
-            updated_at = CURRENT_TIMESTAMP
-        WHERE id = $1
-        RETURNING current_version AS "versionNumber"
-      `, [actId, principal.userId])) as Array<{ versionNumber: number }>;
-      const snapshot = {
-        actId,
-        actCode: act.code,
-        status: InspectionActStatus.DRAFT,
-        reopenedAt: new Date().toISOString(),
-        previousPreparedSha256: closure.preparedSha256,
-      };
-      await manager.query(`
-        INSERT INTO inspection_act_versions (
-          act_id, version_number, event, snapshot, actor_user_id, actor_username
-        ) VALUES ($1, $2, $3, $4, $5, $6)
-      `, [
-        actId,
-        Number(updated.versionNumber),
-        InspectionActVersionEvent.REOPENED,
-        snapshot,
-        principal.userId,
-        principal.username,
-      ]);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_ACT_REOPENED,
-        entityType: 'inspection_act',
-        entityId: actId,
-        afterData: snapshot,
-        metadata: { actId, visitId: visit.id, versionNumber: Number(updated.versionNumber) },
-      }, manager);
-      return this.loadView(manager, actId);
+    throw new ConflictException({
+      code: 'INSPECTION_ACT_LOCK_IS_IMMUTABLE',
+      message: 'Un acta finalizada es inmutable y no puede volver a borrador',
     });
   }
 
@@ -418,17 +409,22 @@ export class InspectionClosingService {
     request: RequestWithContext,
   ): Promise<InspectionClosureView> {
     assertMobileInspector(principal);
-    const identity = {
-      signerType: InspectionActSignerType.INSPECTOR,
-      signerUserId: principal.userId,
-      signerName: `${principal.firstName} ${principal.lastName}`.trim(),
-      documentType: null,
-      documentNumber: null,
-      position: 'Inspector/a',
-      consentText: INSPECTOR_CONSENT,
-      auditAction: AuditAction.INSPECTION_ACT_SIGNATURE_RECORDED,
-    } as const;
-    return this.createSignedSignature(actId, dto, file, identity, principal, request, true);
+    return this.createSignedSignature(
+      actId,
+      dto,
+      file,
+      {
+        signerType: InspectionActSignerType.INSPECTOR,
+        signerUserId: principal.userId,
+        signerName: `${principal.firstName} ${principal.lastName}`.trim(),
+        documentType: null,
+        documentNumber: null,
+        position: 'Inspector/a',
+        consentText: INSPECTOR_CONSENT,
+      },
+      principal,
+      request,
+    );
   }
 
   async signCompany(
@@ -439,7 +435,7 @@ export class InspectionClosingService {
     request: RequestWithContext,
   ): Promise<InspectionClosureView> {
     assertMobileInspector(principal);
-    return this.createSignedSignature(actId, dto, file, null, principal, request, false);
+    return this.createSignedSignature(actId, dto, file, null, principal, request);
   }
 
   async recordCompanyOutcome(
@@ -451,40 +447,29 @@ export class InspectionClosingService {
     assertMobileInspector(principal);
     return this.dataSource.transaction(async (manager) => {
       const { act, visit } = await this.lockContext(manager, actId);
-      this.assertReadyForCompanyOutcome(act, visit);
+      this.assertLockedForManifestation(act);
       await this.assertActorAssigned(manager, visit.id, principal, true);
       const responsible = await this.requireResponsible(manager, actId);
-      if (
-        dto.status === InspectionActSignatureStatus.REFUSED
-        && responsible.attendanceStatus !== InspectionResponsibleAttendanceStatus.PRESENT
-      ) {
+      if (dto.status === InspectionActSignatureStatus.REFUSED
+        && responsible.attendanceStatus !== InspectionResponsibleAttendanceStatus.PRESENT) {
         throw new BadRequestException({
           code: 'INSPECTION_COMPANY_REFUSAL_REQUIRES_PRESENCE',
-          message: 'La negativa a firmar requiere que el responsable esté presente',
+          message: 'La negativa a firmar requiere identificar al responsable que se negó',
         });
       }
-      if (
-        dto.status === InspectionActSignatureStatus.ABSENT
-        && responsible.attendanceStatus !== InspectionResponsibleAttendanceStatus.ABSENT
-      ) {
-        throw new BadRequestException({
-          code: 'INSPECTION_COMPANY_ABSENCE_MISMATCH',
-          message: 'El resultado ausente requiere que el responsable se haya registrado como ausente',
-        });
-      }
-      const closure = await this.requireClosure(manager, actId);
       if (await this.hasCompanyOutcome(manager, actId)) {
         throw new ConflictException({
           code: 'INSPECTION_ACT_COMPANY_OUTCOME_ALREADY_RECORDED',
-          message: 'La recepción de la empresa ya fue registrada y es inmutable',
+          message: 'La manifestación de la empresa ya fue registrada y es inmutable',
         });
       }
-      const source = this.signatureSource(principal);
+      const closure = await this.requireClosure(manager, actId);
       const createdAt = new Date();
-      const signerName = responsible.fullName ?? 'Responsable de la empresa no presente';
+      const source = this.signatureSource(principal);
+      const signerName = responsible.fullName ?? 'Responsable no presente';
       const payload = {
         actId,
-        preparedSha256: closure.preparedSha256,
+        lockedSha256: closure.preparedSha256,
         signerType: InspectionActSignerType.COMPANY_RESPONSIBLE,
         signerName,
         documentType: responsible.documentType,
@@ -493,20 +478,17 @@ export class InspectionClosingService {
         status: dto.status,
         reason: dto.reason,
         source,
-        uploadedBy: principal.userId,
+        recordedBy: principal.userId,
         createdAt: createdAt.toISOString(),
       };
       const signaturePayloadSha256 = sha256CanonicalJson(payload);
       const id = randomUUID();
       await manager.query(`
         INSERT INTO inspection_act_signatures (
-          id, act_id, signer_type, signer_user_id, signer_name,
-          document_type, document_number, position, status, reason,
-          source, prepared_sha256, signature_payload_sha256, uploaded_by, created_at
-        ) VALUES (
-          $1, $2, $3, NULL, $4, $5, $6, $7, $8, $9,
-          $10, $11, $12, $13, $14
-        )
+          id,act_id,signer_type,signer_user_id,signer_name,
+          document_type,document_number,position,status,reason,
+          source,prepared_sha256,signature_payload_sha256,uploaded_by,created_at
+        ) VALUES ($1,$2,$3,NULL,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)
       `, [
         id,
         actId,
@@ -529,12 +511,16 @@ export class InspectionClosingService {
         entityType: 'inspection_act_signature',
         entityId: id,
         afterData: payload,
-        metadata: { actId, visitId: visit.id, immutable: true, signaturePayloadSha256 },
+        metadata: { actId, inspectionId: visit.id, immutable: true },
       }, manager);
       return this.loadView(manager, actId);
     });
   }
 
+  /**
+   * Endpoint legacy /close conservado durante la transición de contratos.
+   * En F4 su semántica es SELLAR, no volver editable ni cerrar la Inspección.
+   */
   async close(
     actId: string,
     dto: CloseInspectionActDto,
@@ -542,30 +528,42 @@ export class InspectionClosingService {
     request: RequestWithContext,
   ): Promise<InspectionClosureView> {
     assertMobileInspector(principal);
-    const closed = await this.dataSource.transaction(async (manager) => {
+    const sealed = await this.dataSource.transaction(async (manager) => {
       const { act, visit } = await this.lockContext(manager, actId);
-      this.assertReadyForFinalClosure(act, visit);
+      this.assertLockedForManifestation(act);
       await this.assertActorAssigned(manager, visit.id, principal, true);
       const closure = await this.requireClosure(manager, actId);
       const signatures = await this.loadSignatures(manager, actId);
-      if (!signatures.some((item) => (
+      const inspectorSigned = signatures.some((item) =>
         item.signerType === InspectionActSignerType.INSPECTOR
-        && item.status === InspectionActSignatureStatus.SIGNED
-      ))) {
+        && item.status === InspectionActSignatureStatus.SIGNED,
+      );
+      if (!inspectorSigned) {
         throw new ConflictException({
           code: 'INSPECTION_ACT_INSPECTOR_SIGNATURE_REQUIRED',
-          message: 'Se requiere al menos una firma de inspector para cerrar el acta',
+          message: 'Se requiere la firma del inspector para sellar el acta',
         });
       }
-      if (signatures.filter((item) => item.signerType === InspectionActSignerType.COMPANY_RESPONSIBLE).length !== 1) {
+      const companyOutcomes = signatures.filter((item) =>
+        item.signerType === InspectionActSignerType.COMPANY_RESPONSIBLE,
+      );
+      if (companyOutcomes.length !== 1) {
         throw new ConflictException({
           code: 'INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED',
-          message: 'Debe registrarse la firma, negativa o ausencia del responsable de la empresa',
+          message: 'Debe existir exactamente una firma, disidencia o negativa del responsable de la empresa',
         });
       }
-      const serverClosedAt = new Date();
-      const deviceClosedAt = new Date(dto.clientClosedAt);
-      if (deviceClosedAt.getTime() > serverClosedAt.getTime() + 24 * 60 * 60 * 1000) {
+      const companyOutcome = companyOutcomes[0];
+      if (companyOutcome.status === InspectionActSignatureStatus.ABSENT) {
+        throw new ConflictException({
+          code: 'INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING',
+          message: 'La ausencia no reemplaza la firma o negativa; la manifestación de la empresa sigue pendiente',
+        });
+      }
+
+      const serverSealedAt = new Date();
+      const deviceSealedAt = new Date(dto.clientClosedAt);
+      if (deviceSealedAt.getTime() > serverSealedAt.getTime() + 24 * 60 * 60 * 1000) {
         throw new BadRequestException({
           code: 'INSPECTION_ACT_INVALID_DEVICE_TIME',
           message: 'La fecha informada por el dispositivo no puede estar más de 24 horas en el futuro',
@@ -601,84 +599,77 @@ export class InspectionClosingService {
       }));
       const finalSnapshot = {
         schemaVersion: CLOSURE_SCHEMA_VERSION,
-        preparedSha256: closure.preparedSha256,
-        preparedSnapshot: closure.preparedSnapshot,
+        lockedSha256: closure.preparedSha256,
+        lockedSnapshot: closure.preparedSnapshot,
         signatures: signatureSnapshot,
-        closure: {
-          deviceClosedAt: deviceClosedAt.toISOString(),
-          serverClosedAt: serverClosedAt.toISOString(),
+        seal: {
+          deviceSealedAt: deviceSealedAt.toISOString(),
+          serverSealedAt: serverSealedAt.toISOString(),
           uploadMode: dto.uploadMode,
-          closedBy: principal.userId,
-          closedByUsername: principal.username,
+          sealedBy: principal.userId,
+          sealedByUsername: principal.username,
         },
       };
       const finalSha256 = sha256CanonicalJson(finalSnapshot);
       await manager.query(`
         UPDATE inspection_act_closures
-        SET final_snapshot = $2,
-            final_sha256 = $3,
-            device_closed_at = $4,
-            server_closed_at = $5,
-            upload_mode = $6,
-            closed_by = $7
-        WHERE act_id = $1
-      `, [
-        actId,
-        finalSnapshot,
-        finalSha256,
-        deviceClosedAt,
-        serverClosedAt,
-        dto.uploadMode,
-        principal.userId,
-      ]);
+        SET final_snapshot=$2,
+            final_sha256=$3,
+            device_closed_at=$4,
+            server_closed_at=$5,
+            upload_mode=$6,
+            closed_by=$7
+        WHERE act_id=$1
+      `, [actId, finalSnapshot, finalSha256, deviceSealedAt, serverSealedAt, dto.uploadMode, principal.userId]);
       const [updated] = (await manager.query(`
         UPDATE inspection_acts
-        SET status = 'CLOSED',
-            closed_at = $2,
-            closed_by = $3,
-            closure_sha256 = $4,
-            current_version = current_version + 1,
-            updated_by = $3,
-            updated_at = $2
-        WHERE id = $1
+        SET status='SEALED',
+            sealed_at=$2,
+            sealed_by=$3,
+            closed_at=$2,
+            closed_by=$3,
+            closure_sha256=$4,
+            current_version=current_version+1,
+            updated_by=$3,
+            updated_at=$2
+        WHERE id=$1
         RETURNING current_version AS "versionNumber"
-      `, [actId, serverClosedAt, principal.userId, finalSha256])) as Array<{ versionNumber: number }>;
+      `, [actId, serverSealedAt, principal.userId, finalSha256])) as Array<{ versionNumber: number }>;
       await manager.query(`
         INSERT INTO inspection_act_versions (
-          act_id, version_number, event, snapshot, actor_user_id, actor_username
-        ) VALUES ($1, $2, $3, $4, $5, $6)
+          act_id,version_number,event,snapshot,actor_user_id,actor_username
+        ) VALUES ($1,$2,$3,$4,$5,$6)
       `, [
         actId,
         Number(updated.versionNumber),
-        InspectionActVersionEvent.CLOSED,
+        InspectionActVersionEvent.SEALED,
         finalSnapshot,
         principal.userId,
         principal.username,
       ]);
       await this.audit.record({
         ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_ACT_CLOSED,
+        action: AuditAction.INSPECTION_ACT_SEALED,
         entityType: 'inspection_act',
         entityId: actId,
         afterData: {
-          status: InspectionActStatus.CLOSED,
+          status: InspectionActStatus.SEALED,
           closureSha256: finalSha256,
-          serverClosedAt,
-          uploadMode: dto.uploadMode,
+          sealedAt: serverSealedAt,
         },
         metadata: {
           actId,
-          visitId: visit.id,
+          inspectionId: visit.id,
           versionNumber: Number(updated.versionNumber),
-          findingsRemainOpen: true,
-          visitRemainsIndependent: true,
+          findingsRemainIndependent: true,
+          inspectionRemainsIndependent: true,
         },
       }, manager);
       await this.reports.ensureFrozenReport(manager, actId, principal, request);
       return this.loadView(manager, actId);
     });
     await this.reports.ensureWordForAct(actId);
-    return closed;
+    return sealed;
   }
 
   async signatureContent(signatureId: string): Promise<{
@@ -720,11 +711,9 @@ export class InspectionClosingService {
       documentNumber: null;
       position: string;
       consentText: string;
-      auditAction: AuditAction;
     },
     principal: AuthPrincipal,
     request: RequestWithContext,
-    requireSelfAssignment: boolean,
   ): Promise<InspectionClosureView> {
     this.validateCoordinates(dto.latitude, dto.longitude, dto.accuracyM);
     const inspected = inspectInspectionSignatureFile(file);
@@ -737,15 +726,14 @@ export class InspectionClosingService {
     try {
       return await this.dataSource.transaction(async (manager) => {
         const { act, visit } = await this.lockContext(manager, actId);
-        if (fixedIdentity) this.assertReadyInProgress(act, visit);
-        else this.assertReadyForCompanyOutcome(act, visit);
-        await this.assertActorAssigned(manager, visit.id, principal, !requireSelfAssignment);
+        this.assertLockedForManifestation(act);
+        await this.assertActorAssigned(manager, visit.id, principal, true);
         const closure = await this.requireClosure(manager, actId);
         const responsible = fixedIdentity ? null : await this.requireResponsible(manager, actId);
         if (responsible && responsible.attendanceStatus !== InspectionResponsibleAttendanceStatus.PRESENT) {
           throw new ConflictException({
             code: 'INSPECTION_COMPANY_RESPONSIBLE_ABSENT',
-            message: 'No puede registrarse firma de empresa cuando el responsable está ausente',
+            message: 'No puede registrarse firma de empresa si no se identificó al responsable presente',
           });
         }
         const identity = fixedIdentity ?? {
@@ -756,15 +744,14 @@ export class InspectionClosingService {
           documentNumber: responsible!.documentNumber,
           position: responsible!.position,
           consentText: COMPANY_CONSENT,
-          auditAction: AuditAction.INSPECTION_ACT_SIGNATURE_RECORDED,
         };
         if (identity.signerType === InspectionActSignerType.INSPECTOR) {
-          const [existing] = (await manager.query(`
-            SELECT 1
-            FROM inspection_act_signatures
-            WHERE act_id = $1 AND signer_type = 'INSPECTOR' AND signer_user_id = $2
-          `, [actId, identity.signerUserId])) as unknown[];
-          if (existing) {
+          const existing = await manager.query(`
+            SELECT 1 FROM inspection_act_signatures
+            WHERE act_id=$1 AND signer_type='INSPECTOR' AND signer_user_id=$2
+            LIMIT 1
+          `, [actId, identity.signerUserId]) as unknown[];
+          if (existing.length) {
             throw new ConflictException({
               code: 'INSPECTION_ACT_INSPECTOR_ALREADY_SIGNED',
               message: 'El inspector actual ya firmó esta acta',
@@ -773,9 +760,10 @@ export class InspectionClosingService {
         } else if (await this.hasCompanyOutcome(manager, actId)) {
           throw new ConflictException({
             code: 'INSPECTION_ACT_COMPANY_OUTCOME_ALREADY_RECORDED',
-            message: 'La recepción de la empresa ya fue registrada y es inmutable',
+            message: 'La manifestación de la empresa ya fue registrada y es inmutable',
           });
         }
+
         const source = this.signatureSource(principal);
         const signedAt = new Date();
         const clientSignedAt = dto.clientSignedAt ? new Date(dto.clientSignedAt) : null;
@@ -788,7 +776,7 @@ export class InspectionClosingService {
           : null;
         const payload = {
           actId,
-          preparedSha256: closure.preparedSha256,
+          lockedSha256: closure.preparedSha256,
           signerType: identity.signerType,
           signerUserId: identity.signerUserId,
           signerName: identity.signerName,
@@ -814,23 +802,17 @@ export class InspectionClosingService {
         const signaturePayloadSha256 = sha256CanonicalJson(payload);
         await manager.query(`
           INSERT INTO inspection_act_signatures (
-            id, act_id, signer_type, signer_user_id, signer_name,
-            document_type, document_number, position, status,
-            company_manifestation, company_statement,
-            original_name, stored_name, mime_type, size_bytes, image_sha256,
-            consent_text, consent_version, consent_accepted_at,
-            client_signed_at, signed_at, latitude, longitude, accuracy_m,
-            device_label, source, prepared_sha256, signature_payload_sha256,
-            uploaded_by, created_at
+            id,act_id,signer_type,signer_user_id,signer_name,
+            document_type,document_number,position,status,
+            company_manifestation,company_statement,
+            original_name,stored_name,mime_type,size_bytes,image_sha256,
+            consent_text,consent_version,consent_accepted_at,
+            client_signed_at,signed_at,latitude,longitude,accuracy_m,
+            device_label,source,prepared_sha256,signature_payload_sha256,
+            uploaded_by,created_at
           ) VALUES (
-            $1, $2, $3, $4, $5,
-            $6, $7, $8, 'SIGNED',
-            $9, $10,
-            $11, $12, $13, $14, $15,
-            $16, $17, $18,
-            $19, $20, $21, $22, $23,
-            $24, $25, $26, $27,
-            $28, $20
+            $1,$2,$3,$4,$5,$6,$7,$8,'SIGNED',$9,$10,$11,$12,$13,$14,$15,
+            $16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$20
           )
         `, [
           id,
@@ -864,16 +846,11 @@ export class InspectionClosingService {
         ]);
         await this.audit.record({
           ...administrationAuditContext(principal, request),
-          action: identity.auditAction,
+          action: AuditAction.INSPECTION_ACT_SIGNATURE_RECORDED,
           entityType: 'inspection_act_signature',
           entityId: id,
           afterData: payload,
-          metadata: {
-            actId,
-            visitId: visit.id,
-            immutable: true,
-            signaturePayloadSha256,
-          },
+          metadata: { actId, inspectionId: visit.id, immutable: true },
         }, manager);
         return this.loadView(manager, actId);
       });
@@ -883,116 +860,50 @@ export class InspectionClosingService {
     }
   }
 
-  private async buildPreparedSnapshot(
+  private async buildLockedSnapshot(
     manager: EntityManager,
     actId: string,
-    preparedAt: Date,
+    lockedAt: Date,
   ): Promise<Record<string, unknown>> {
-    const [act] = (await manager.query(`
-      SELECT
-        act.id,
-        act.code,
-        act.act_year AS "actYear",
-        act.act_number AS "actNumber",
-        act.status,
-        act.occurred_at AS "occurredAt",
-        act.title,
-        act.summary,
-        act.observations,
-        act.current_version AS "currentVersion",
-        act.created_at AS "createdAt",
-        act.updated_at AS "updatedAt",
-        JSONB_BUILD_OBJECT(
-          'id', visit.id,
-          'code', visit.code,
-          'title', visit.title,
-          'objective', visit.objective,
-          'status', visit.status,
-          'scopeAssetId', visit.scope_asset_id,
-          'leadInspectorUserId', visit.lead_inspector_user_id,
-          'plannedStartAt', visit.planned_start_at,
-          'plannedEndAt', visit.planned_end_at,
-          'actualStartedAt', visit.actual_started_at,
-          'instructions', visit.instructions
-        ) AS visit
+    const [act] = await manager.query(`
+      SELECT JSONB_BUILD_OBJECT(
+        'id',act.id,
+        'code',act.code,
+        'status',act.status,
+        'occurredAt',act.occurred_at,
+        'title',act.title,
+        'summary',act.summary,
+        'observations',act.observations,
+        'urgency',act.urgency,
+        'deadlineDays',act.deadline_days,
+        'deadlineDayType',act.deadline_day_type,
+        'deadlineBasis',act.deadline_basis,
+        'deadlineBaseAt',act.deadline_base_at,
+        'deadlineAt',act.deadline_at,
+        'inspection',JSONB_BUILD_OBJECT(
+          'id',visit.id,
+          'code',visit.code,
+          'status',visit.status,
+          'operationalAreaId',visit.operational_area_id,
+          'operatorCompanyId',visit.operator_company_id,
+          'leadInspectorUserId',visit.lead_inspector_user_id,
+          'actualStartedAt',visit.actual_started_at
+        )
+      ) AS act
       FROM inspection_acts act
-      INNER JOIN inspection_visits visit ON visit.id = act.visit_id
-      WHERE act.id = $1
-    `, [actId])) as Array<Record<string, unknown>>;
+      JOIN inspection_visits visit ON visit.id=act.visit_id
+      WHERE act.id=$1
+    `, [actId]) as Array<{ act: Record<string, unknown> }>;
     if (!act) throw actNotFound();
     const responsible = await this.requireResponsible(manager, actId);
-    const team = await manager.query(`
-      SELECT
-        member.user_id AS "userId",
-        user_account.username,
-        user_account.first_name AS "firstName",
-        user_account.last_name AS "lastName",
-        user_account.email,
-        (visit.lead_inspector_user_id = member.user_id) AS "isLead"
-      FROM inspection_visit_members member
-      INNER JOIN inspection_visits visit ON visit.id = member.visit_id
-      INNER JOIN users user_account ON user_account.id = member.user_id
-      WHERE member.visit_id = $1 AND member.included = true
-      ORDER BY "isLead" DESC, user_account.username, member.user_id
-    `, [(act.visit as { id: string }).id]) as Array<Record<string, unknown>>;
-    const assets = await manager.query(`
-      SELECT
-        asset.id,
-        asset.code,
-        asset.name,
-        asset.common_name AS "commonName",
-        asset.description,
-        asset.parent_id AS "parentId",
-        CASE WHEN company.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', company.id,
-          'code', company.code,
-          'name', company.name,
-          'commonName', company.common_name
-        ) END AS "operatorCompany",
-        CASE WHEN area.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', area.id,
-          'code', area.code,
-          'name', area.name,
-          'commonName', area.common_name
-        ) END AS "operationalArea",
-        asset.information_status AS "informationStatus",
-        asset.current_version AS "currentVersion",
-        asset.data_origin AS "dataOrigin",
-        asset.source_name AS "sourceName",
-        asset.source_reference AS "sourceReference",
-        asset.source_observed_at AS "sourceObservedAt",
-        asset_type.id AS "typeId",
-        asset_type.code AS "typeCode",
-        asset_type.name AS "typeName",
-        COALESCE((
-          SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
-            'definitionId', definition.id,
-            'code', definition.code,
-            'name', definition.name,
-            'dataType', definition.data_type,
-            'value', attribute_value.value
-          ) ORDER BY definition.sort_order, definition.code, definition.id)
-          FROM asset_attribute_values attribute_value
-          INNER JOIN asset_attribute_definitions definition
-            ON definition.id = attribute_value.definition_id
-          WHERE attribute_value.asset_id = asset.id
-        ), '[]'::jsonb) AS attributes,
-        CASE WHEN geometry.asset_id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'type', geometry.geometry_type,
-          'geojson', ST_AsGeoJSON(geometry.geometry)::jsonb,
-          'source', geometry.source,
-          'accuracyM', geometry.accuracy_m,
-          'capturedAt', geometry.captured_at,
-          'deviceLabel', geometry.device_label
-        ) END AS geometry
+    const inventories = await manager.query(`
+      SELECT asset.id,asset.code,asset.name,asset.current_version AS "currentVersion",
+             type.code AS "typeCode",type.name AS "typeName"
       FROM inspection_act_assets link
-      INNER JOIN assets asset ON asset.id = link.asset_id
-      INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
-      LEFT JOIN assets company ON company.id = asset.operator_company_id
-      LEFT JOIN assets area ON area.id = asset.operational_area_id
-      LEFT JOIN asset_geometries geometry ON geometry.asset_id = asset.id
-      WHERE link.act_id = $1 AND link.included = true
-      ORDER BY asset.code, asset.id
+      JOIN assets asset ON asset.id=link.asset_id
+      JOIN asset_types type ON type.id=asset.asset_type_id
+      WHERE link.act_id=$1 AND link.included=true
+      ORDER BY asset.code,asset.id
     `, [actId]) as Array<Record<string, unknown>>;
     const findings = await manager.query(`
       SELECT
@@ -1005,159 +916,129 @@ export class InspectionClosingService {
         finding.title,
         finding.description,
         finding.legal_basis AS "legalBasis",
-        finding.glossary,
-        finding.catalog_revision AS "catalogRevision",
-        finding.suggested_severity AS "suggestedSeverity",
         finding.severity,
+        finding.is_recurrence AS "isRecurrence",
+        finding.recurrence_of_finding_id AS "recurrenceOfFindingId",
         finding.correction_due_on AS "correctionDueOn",
-        finding.company_response AS "companyResponse",
-        finding.company_response_received_on AS "companyResponseReceivedOn",
-        finding.company_committed_correction_on AS "companyCommittedCorrectionOn",
-        finding.next_control_on AS "nextControlOn",
-        finding.current_version AS "currentVersion",
-        JSONB_BUILD_OBJECT(
-          'code', catalog.code,
-          'sourceNumber', catalog.source_number,
-          'title', catalog.title,
-          'revision', catalog.revision,
-          'suggestedSeverity', finding.suggested_severity,
-          'categoryCode', category.code,
-          'categoryName', category.name
-        ) AS catalog,
-        COALESCE((
-          SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
-            'id', evidence.id,
-            'communicationId', evidence.communication_id,
-            'kind', evidence.kind,
-            'purpose', evidence.purpose,
-            'originalName', evidence.original_name,
-            'mimeType', evidence.mime_type,
-            'sizeBytes', evidence.size_bytes,
-            'sha256', evidence.sha256,
-            'title', evidence.title,
-            'description', evidence.description,
-            'capturedAt', evidence.captured_at,
-            'latitude', evidence.latitude,
-            'longitude', evidence.longitude,
-            'accuracyM', evidence.accuracy_m,
-            'deviceLabel', evidence.device_label,
-            'source', evidence.source,
-            'uploadedBy', evidence.uploaded_by,
-            'createdAt', evidence.created_at
-          ) ORDER BY evidence.created_at, evidence.id)
-          FROM inspection_finding_evidence evidence
-          WHERE evidence.finding_id = finding.id
-        ), '[]'::jsonb) AS evidence,
-        COALESCE((
-          SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
-            'id', communication.id,
-            'direction', communication.direction,
-            'channel', communication.channel,
-            'type', communication.type,
-            'occurredAt', communication.occurred_at,
-            'subject', communication.subject,
-            'details', communication.details,
-            'contactName', communication.contact_name,
-            'contactEmail', communication.contact_email,
-            'createdBy', communication.created_by,
-            'createdAt', communication.created_at
-          ) ORDER BY communication.occurred_at, communication.id)
-          FROM inspection_finding_communications communication
-          WHERE communication.finding_id = finding.id
-        ), '[]'::jsonb) AS communications
+        finding.current_version AS "currentVersion"
       FROM inspection_findings finding
-      LEFT JOIN finding_catalog_items catalog ON catalog.id = finding.catalog_item_id
-      LEFT JOIN finding_categories category ON category.id = catalog.category_id
-      WHERE finding.act_id = $1 AND finding.status <> 'VOIDED'
-      ORDER BY finding.finding_number, finding.id
+      WHERE finding.act_id=$1 AND finding.status<>'VOIDED'
+      ORDER BY finding.finding_number,finding.id
     `, [actId]) as Array<Record<string, unknown>>;
-    const verificationResults = await manager.query(`
-      SELECT
-        verification_link.finding_id AS "findingId",
-        finding.code AS "findingCode",
-        finding.title AS "findingTitle",
-        finding.description AS "findingDescription",
-        finding.asset_id AS "assetId",
-        asset.code AS "assetCode",
-        asset.name AS "assetName",
-        verification_link.target_control_on AS "targetControlOn",
-        verification_link.outcome,
-        verification_link.result_notes AS "resultNotes",
-        verification_link.verified_at AS "verifiedAt",
-        verification_link.result_recorded_at AS "resultRecordedAt",
-        verification_link.rescheduled_control_on AS "rescheduledControlOn",
-        COALESCE((
-          SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
-            'id', evidence.id,
-            'kind', evidence.kind,
-            'purpose', evidence.purpose,
-            'originalName', evidence.original_name,
-            'mimeType', evidence.mime_type,
-            'sizeBytes', evidence.size_bytes,
-            'sha256', evidence.sha256,
-            'title', evidence.title,
-            'description', evidence.description,
-            'capturedAt', evidence.captured_at,
-            'latitude', evidence.latitude,
-            'longitude', evidence.longitude,
-            'accuracyM', evidence.accuracy_m,
-            'deviceLabel', evidence.device_label,
-            'source', evidence.source,
-            'uploadedBy', evidence.uploaded_by,
-            'createdAt', evidence.created_at
-          ) ORDER BY evidence.created_at, evidence.id)
-          FROM inspection_finding_evidence evidence
-          WHERE evidence.finding_id = finding.id
-            AND evidence.verification_visit_id = $1
-            AND evidence.purpose = 'VERIFICATION'
-        ), '[]'::jsonb) AS evidence
-      FROM inspection_finding_verification_visits verification_link
-      INNER JOIN inspection_findings finding ON finding.id = verification_link.finding_id
-      INNER JOIN assets asset ON asset.id = finding.asset_id
-      WHERE verification_link.visit_id = $1
-      ORDER BY finding.code
-    `, [(act.visit as { id: string }).id]) as Array<Record<string, unknown>>;
     return {
       schemaVersion: CLOSURE_SCHEMA_VERSION,
-      preparedAt: preparedAt.toISOString(),
-      act,
+      lockedAt: lockedAt.toISOString(),
+      act: act.act,
       responsible,
-      team,
-      assets,
+      inventories,
       findings,
-      verificationResults,
     };
   }
 
-  private async loadView(manager: EntityManager, actId: string): Promise<InspectionClosureView> {
-    const [context] = (await manager.query(`
+  private async assertVerificationResultsComplete(manager: EntityManager, inspectionId: string): Promise<void> {
+    const [row] = await manager.query(`
       SELECT
-        act.id,
-        act.code,
-        act.status,
-        act.visit_id AS "visitId",
+        COUNT(*)::integer AS total,
+        COUNT(*) FILTER (WHERE outcome IS NOT NULL)::integer AS completed
+      FROM inspection_finding_verification_visits
+      WHERE visit_id=$1
+    `, [inspectionId]) as Array<{ total: number; completed: number }>;
+    if (Number(row?.total ?? 0) > 0 && Number(row.completed) !== Number(row.total)) {
+      throw new ConflictException({
+        code: 'INSPECTION_VERIFICATION_RESULTS_REQUIRED',
+        message: 'Registrá el resultado de todas las verificaciones antes de finalizar el acta',
+      });
+    }
+  }
+
+  private async deadlinePolicy(manager: EntityManager): Promise<DeadlinePolicy> {
+    const [row] = await manager.query(`
+      SELECT
+        urgent_days AS "urgentDays",
+        urgent_day_type AS "urgentDayType",
+        non_urgent_days AS "nonUrgentDays",
+        non_urgent_day_type AS "nonUrgentDayType"
+      FROM inspection_deadline_policies
+      ORDER BY created_at
+      LIMIT 1
+    `) as DeadlinePolicy[];
+    return row ?? {
+      urgentDays: 5,
+      urgentDayType: InspectionDeadlineDayType.BUSINESS,
+      nonUrgentDays: 10,
+      nonUrgentDayType: InspectionDeadlineDayType.BUSINESS,
+    };
+  }
+
+  private async calculateDeadline(
+    manager: EntityManager,
+    baseAt: Date,
+    days: number,
+    dayType: InspectionDeadlineDayType,
+  ): Promise<Date> {
+    if (dayType === InspectionDeadlineDayType.CALENDAR) {
+      const [row] = await manager.query(`
+        SELECT (
+          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + $2::integer)::timestamp
+          + time '23:59:59'
+        ) AT TIME ZONE 'America/Argentina/Mendoza' AS due_at
+      `, [baseAt, days]) as Array<{ due_at: Date }>;
+      return row.due_at;
+    }
+    const [row] = await manager.query(`
+      WITH candidates AS (
+        SELECT
+          day::date AS day,
+          COALESCE(override.is_business_day, EXTRACT(ISODOW FROM day)::integer BETWEEN 1 AND 5) AS business
+        FROM generate_series(
+          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + 1)::timestamp,
+          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + 730)::timestamp,
+          interval '1 day'
+        ) day
+        LEFT JOIN inspection_business_calendar_days override ON override.date=day::date
+      ), ranked AS (
+        SELECT day,ROW_NUMBER() OVER (ORDER BY day) AS position
+        FROM candidates
+        WHERE business=true
+      )
+      SELECT ((day::timestamp + time '23:59:59') AT TIME ZONE 'America/Argentina/Mendoza') AS due_at
+      FROM ranked
+      WHERE position=$2
+      LIMIT 1
+    `, [baseAt, days]) as Array<{ due_at: Date }>;
+    if (!row?.due_at) throw new InternalServerErrorException('No se pudo calcular el vencimiento');
+    return row.due_at;
+  }
+
+  private async loadView(manager: EntityManager, actId: string): Promise<InspectionClosureView> {
+    const [context] = await manager.query(`
+      SELECT
+        act.id,act.code,act.status,act.visit_id AS "visitId",
+        act.urgency,
+        act.deadline_days AS "deadlineDays",
+        act.deadline_day_type AS "deadlineDayType",
+        act.deadline_basis AS "deadlineBasis",
+        act.deadline_base_at AS "deadlineBaseAt",
+        act.deadline_at AS "deadlineAt",
+        act.locked_at AS "lockedAt",
+        act.locked_sha256 AS "lockedSha256",
+        act.sealed_at AS "sealedAt",
         act.current_version AS "currentVersion",
-        act.closed_at AS "closedAt",
-        act.closed_by AS "closedBy",
+        act.closed_at AS "closedAt",act.closed_by AS "closedBy",
         act.closure_sha256 AS "closureSha256",
-        visit.code AS "visitCode",
-        visit.status AS "visitStatus",
+        visit.code AS "visitCode",visit.status AS "visitStatus",
         visit.actual_closed_at AS "visitActualClosedAt"
       FROM inspection_acts act
-      INNER JOIN inspection_visits visit ON visit.id = act.visit_id
-      WHERE act.id = $1
-    `, [actId])) as Array<{
-      id: string;
-      code: string;
-      status: InspectionActStatus;
-      visitId: string;
-      currentVersion: number;
-      closedAt: Date | null;
-      closedBy: string | null;
-      closureSha256: string | null;
-      visitCode: string;
-      visitStatus: InspectionVisitStatus;
-      visitActualClosedAt: Date | null;
+      JOIN inspection_visits visit ON visit.id=act.visit_id
+      WHERE act.id=$1
+    `, [actId]) as Array<{
+      id: string; code: string; status: InspectionActStatus; visitId: string;
+      urgency: InspectionActUrgency; deadlineDays: number | null;
+      deadlineDayType: InspectionDeadlineDayType | null; deadlineBasis: InspectionDeadlineBasis | null;
+      deadlineBaseAt: Date | null; deadlineAt: Date | null; lockedAt: Date | null;
+      lockedSha256: string | null; sealedAt: Date | null; currentVersion: number;
+      closedAt: Date | null; closedBy: string | null; closureSha256: string | null;
+      visitCode: string; visitStatus: InspectionVisitStatus; visitActualClosedAt: Date | null;
     }>;
     if (!context) throw actNotFound();
     const responsible = await this.loadResponsible(manager, actId);
@@ -1169,6 +1050,15 @@ export class InspectionClosingService {
         code: context.code,
         status: context.status,
         visitId: context.visitId,
+        urgency: context.urgency,
+        deadlineDays: context.deadlineDays,
+        deadlineDayType: context.deadlineDayType,
+        deadlineBasis: context.deadlineBasis,
+        deadlineBaseAt: context.deadlineBaseAt,
+        deadlineAt: context.deadlineAt,
+        lockedAt: context.lockedAt,
+        lockedSha256: context.lockedSha256,
+        sealedAt: context.sealedAt,
         currentVersion: Number(context.currentVersion),
         closedAt: context.closedAt,
         closedBy: context.closedBy,
@@ -1191,8 +1081,7 @@ export class InspectionClosingService {
         serverClosedAt: closure.serverClosedAt,
         uploadMode: closure.uploadMode,
         closedBy: closure.closedBy,
-        isCurrent: context.status === InspectionActStatus.READY
-          || context.status === InspectionActStatus.CLOSED,
+        isCurrent: [InspectionActStatus.LOCKED, InspectionActStatus.SEALED].includes(context.status),
       } : null,
       signatures,
       consents: {
@@ -1204,23 +1093,13 @@ export class InspectionClosingService {
   }
 
   private async loadResponsible(manager: EntityManager, actId: string): Promise<ResponsibleView | null> {
-    const [row] = (await manager.query(`
-      SELECT
-        act_id AS "actId",
-        attendance_status AS "attendanceStatus",
-        full_name AS "fullName",
-        document_type AS "documentType",
-        document_number AS "documentNumber",
-        position,
-        email,
-        phone,
-        absence_reason AS "absenceReason",
-        updated_by AS "updatedBy",
-        created_at AS "createdAt",
-        updated_at AS "updatedAt"
-      FROM inspection_act_responsibles
-      WHERE act_id = $1
-    `, [actId])) as ResponsibleView[];
+    const [row] = await manager.query(`
+      SELECT act_id AS "actId",attendance_status AS "attendanceStatus",
+        full_name AS "fullName",document_type AS "documentType",document_number AS "documentNumber",
+        position,email,phone,absence_reason AS "absenceReason",updated_by AS "updatedBy",
+        created_at AS "createdAt",updated_at AS "updatedAt"
+      FROM inspection_act_responsibles WHERE act_id=$1
+    `, [actId]) as ResponsibleView[];
     return row ?? null;
   }
 
@@ -1229,30 +1108,22 @@ export class InspectionClosingService {
     if (!responsible) {
       throw new ConflictException({
         code: 'INSPECTION_ACT_RESPONSIBLE_REQUIRED',
-        message: 'Debe identificarse al responsable presente o documentar su ausencia',
+        message: 'Debe identificarse al responsable o documentar su ausencia antes de finalizar el acta',
       });
     }
     return responsible;
   }
 
   private async loadClosure(manager: EntityManager, actId: string): Promise<ClosureRecord | null> {
-    const [row] = (await manager.query(`
-      SELECT
-        act_id AS "actId",
-        schema_version AS "schemaVersion",
-        prepared_snapshot AS "preparedSnapshot",
-        prepared_sha256 AS "preparedSha256",
-        prepared_at AS "preparedAt",
-        prepared_by AS "preparedBy",
-        final_snapshot AS "finalSnapshot",
-        final_sha256 AS "finalSha256",
-        device_closed_at AS "deviceClosedAt",
-        server_closed_at AS "serverClosedAt",
-        upload_mode AS "uploadMode",
-        closed_by AS "closedBy"
-      FROM inspection_act_closures
-      WHERE act_id = $1
-    `, [actId])) as ClosureRecord[];
+    const [row] = await manager.query(`
+      SELECT act_id AS "actId",schema_version AS "schemaVersion",
+        prepared_snapshot AS "preparedSnapshot",prepared_sha256 AS "preparedSha256",
+        prepared_at AS "preparedAt",prepared_by AS "preparedBy",
+        final_snapshot AS "finalSnapshot",final_sha256 AS "finalSha256",
+        device_closed_at AS "deviceClosedAt",server_closed_at AS "serverClosedAt",
+        upload_mode AS "uploadMode",closed_by AS "closedBy"
+      FROM inspection_act_closures WHERE act_id=$1
+    `, [actId]) as ClosureRecord[];
     return row ?? null;
   }
 
@@ -1260,8 +1131,8 @@ export class InspectionClosingService {
     const closure = await this.loadClosure(manager, actId);
     if (!closure) {
       throw new ConflictException({
-        code: 'INSPECTION_ACT_NOT_PREPARED',
-        message: 'El acta todavía no fue preparada para firmas',
+        code: 'INSPECTION_ACT_NOT_LOCKED',
+        message: 'El acta todavía no fue finalizada y bloqueada',
       });
     }
     return closure;
@@ -1269,96 +1140,61 @@ export class InspectionClosingService {
 
   private signatureSelect(): string {
     return `
-      SELECT
-        signature.id,
-        signature.act_id AS "actId",
-        signature.signer_type AS "signerType",
-        signature.signer_user_id AS "signerUserId",
-        signature.signer_name AS "signerName",
-        signature.document_type AS "documentType",
-        signature.document_number AS "documentNumber",
-        signature.position,
-        signature.status,
-        signature.reason,
+      SELECT signature.id,signature.act_id AS "actId",signature.signer_type AS "signerType",
+        signature.signer_user_id AS "signerUserId",signature.signer_name AS "signerName",
+        signature.document_type AS "documentType",signature.document_number AS "documentNumber",
+        signature.position,signature.status,signature.reason,
         signature.company_manifestation AS "companyManifestation",
         signature.company_statement AS "companyStatement",
-        signature.original_name AS "originalName",
-        signature.stored_name AS "storedName",
-        signature.mime_type AS "mimeType",
-        signature.size_bytes::integer AS "sizeBytes",
-        signature.image_sha256 AS "imageSha256",
-        signature.consent_text AS "consentText",
-        signature.consent_version AS "consentVersion",
-        signature.consent_accepted_at AS "consentAcceptedAt",
-        signature.client_signed_at AS "clientSignedAt",
-        signature.signed_at AS "signedAt",
-        signature.latitude::double precision AS latitude,
-        signature.longitude::double precision AS longitude,
-        signature.accuracy_m::double precision AS "accuracyM",
-        signature.device_label AS "deviceLabel",
-        signature.source,
-        signature.prepared_sha256 AS "preparedSha256",
+        signature.original_name AS "originalName",signature.stored_name AS "storedName",
+        signature.mime_type AS "mimeType",signature.size_bytes::integer AS "sizeBytes",
+        signature.image_sha256 AS "imageSha256",signature.consent_text AS "consentText",
+        signature.consent_version AS "consentVersion",signature.consent_accepted_at AS "consentAcceptedAt",
+        signature.client_signed_at AS "clientSignedAt",signature.signed_at AS "signedAt",
+        signature.latitude::double precision AS latitude,signature.longitude::double precision AS longitude,
+        signature.accuracy_m::double precision AS "accuracyM",signature.device_label AS "deviceLabel",
+        signature.source,signature.prepared_sha256 AS "preparedSha256",
         signature.signature_payload_sha256 AS "signaturePayloadSha256",
-        signature.uploaded_by AS "uploadedBy",
-        uploader.username AS "uploadedByUsername",
+        signature.uploaded_by AS "uploadedBy",uploader.username AS "uploadedByUsername",
         signature.created_at AS "createdAt"
       FROM inspection_act_signatures signature
-      INNER JOIN users uploader ON uploader.id = signature.uploaded_by
+      JOIN users uploader ON uploader.id=signature.uploaded_by
     `;
   }
 
   private async loadSignatures(manager: EntityManager, actId: string): Promise<SignatureView[]> {
     const rows = await manager.query(`
-      ${this.signatureSelect()}
-      WHERE signature.act_id = $1
-      ORDER BY signature.signer_type, signature.created_at, signature.id
+      ${this.signatureSelect()} WHERE signature.act_id=$1
+      ORDER BY signature.signer_type,signature.created_at,signature.id
     `, [actId]) as StoredSignature[];
     return rows.map(({ storedName: _storedName, originalName: _originalName, ...row }) => row);
   }
 
   private async loadStoredSignature(manager: EntityManager, id: string): Promise<StoredSignature> {
-    const [row] = await manager.query(`
-      ${this.signatureSelect()}
-      WHERE signature.id = $1
-    `, [id]) as StoredSignature[];
+    const [row] = await manager.query(`${this.signatureSelect()} WHERE signature.id=$1`, [id]) as StoredSignature[];
     if (!row) throw signatureNotFound();
     return row;
   }
 
   private async signatureCount(manager: EntityManager, actId: string): Promise<number> {
-    const [row] = (await manager.query(`
-      SELECT COUNT(*)::integer AS total
-      FROM inspection_act_signatures
-      WHERE act_id = $1
-    `, [actId])) as Array<{ total: number }>;
+    const [row] = await manager.query(`SELECT COUNT(*)::integer AS total FROM inspection_act_signatures WHERE act_id=$1`, [actId]) as Array<{ total: number }>;
     return Number(row?.total ?? 0);
   }
 
   private async hasCompanyOutcome(manager: EntityManager, actId: string): Promise<boolean> {
     const rows = await manager.query(`
-      SELECT 1
-      FROM inspection_act_signatures
-      WHERE act_id = $1 AND signer_type = 'COMPANY_RESPONSIBLE'
-      LIMIT 1
+      SELECT 1 FROM inspection_act_signatures
+      WHERE act_id=$1 AND signer_type='COMPANY_RESPONSIBLE' LIMIT 1
     `, [actId]) as unknown[];
     return rows.length > 0;
   }
 
-  private async lockContext(
-    manager: EntityManager,
-    actId: string,
-  ): Promise<{ act: InspectionAct; visit: InspectionVisit }> {
+  private async lockContext(manager: EntityManager, actId: string): Promise<{ act: InspectionAct; visit: InspectionVisit }> {
     const act = await manager.getRepository(InspectionAct)
-      .createQueryBuilder('act')
-      .where('act.id = :actId', { actId })
-      .setLock('pessimistic_write')
-      .getOne();
+      .createQueryBuilder('act').where('act.id=:actId', { actId }).setLock('pessimistic_write').getOne();
     if (!act) throw actNotFound();
     const visit = await manager.getRepository(InspectionVisit)
-      .createQueryBuilder('visit')
-      .where('visit.id = :visitId', { visitId: act.visitId })
-      .setLock('pessimistic_write')
-      .getOne();
+      .createQueryBuilder('visit').where('visit.id=:visitId', { visitId: act.visitId }).setLock('pessimistic_write').getOne();
     if (!visit) throw actNotFound();
     return { act, visit };
   }
@@ -1367,56 +1203,35 @@ export class InspectionClosingService {
     if (act.status !== InspectionActStatus.DRAFT || visit.status !== InspectionVisitStatus.IN_PROGRESS) {
       throw new ConflictException({
         code: 'INSPECTION_ACT_NOT_EDITABLE',
-        message: 'El responsable sólo puede modificarse con el acta en borrador y la visita en curso',
+        message: 'El acta sólo puede editarse mientras está en borrador y la inspección está en curso',
       });
     }
   }
 
-  private assertReadyInProgress(act: InspectionAct, visit: InspectionVisit): void {
-    if (act.status !== InspectionActStatus.READY || visit.status !== InspectionVisitStatus.IN_PROGRESS) {
+  private assertLockedForManifestation(act: InspectionAct): void {
+    if (act.status !== InspectionActStatus.LOCKED) {
       throw new ConflictException({
-        code: 'INSPECTION_ACT_NOT_READY',
-        message: 'El acta debe estar preparada y la visita en curso',
-      });
-    }
-  }
-
-  private assertReadyForCompanyOutcome(act: InspectionAct, visit: InspectionVisit): void {
-    if (act.status !== InspectionActStatus.READY
-      || ![InspectionVisitStatus.IN_PROGRESS, InspectionVisitStatus.CLOSED].includes(visit.status)) {
-      throw new ConflictException({
-        code: 'INSPECTION_ACT_NOT_READY_FOR_COMPANY',
-        message: 'El acta debe estar preparada; la firma de empresa puede completarse durante la inspección o después de su cierre',
-      });
-    }
-  }
-
-  private assertReadyForFinalClosure(act: InspectionAct, visit: InspectionVisit): void {
-    if (act.status !== InspectionActStatus.READY
-      || ![InspectionVisitStatus.IN_PROGRESS, InspectionVisitStatus.CLOSED].includes(visit.status)) {
-      throw new ConflictException({
-        code: 'INSPECTION_ACT_NOT_READY',
-        message: 'El acta debe estar preparada para completar su cierre definitivo',
+        code: 'INSPECTION_ACT_NOT_LOCKED',
+        message: 'El acta debe estar finalizada y bloqueada antes de firmarse o sellarse',
       });
     }
   }
 
   private async assertActorAssigned(
     manager: EntityManager,
-    visitId: string,
+    inspectionId: string,
     principal: AuthPrincipal,
     allowManager: boolean,
   ): Promise<void> {
     if (allowManager && principal.permissions.includes('inspections.manage')) return;
     const rows = await manager.query(`
-      SELECT 1
-      FROM inspection_visit_members
-      WHERE visit_id = $1 AND user_id = $2 AND included = true
-    `, [visitId, principal.userId]) as unknown[];
-    if (rows.length === 0) {
+      SELECT 1 FROM inspection_visit_members
+      WHERE visit_id=$1 AND user_id=$2 AND included=true
+    `, [inspectionId, principal.userId]) as unknown[];
+    if (!rows.length) {
       throw new ForbiddenException({
         code: 'INSPECTION_VISIT_NOT_ASSIGNED',
-        message: 'Sólo un integrante asignado a la visita puede realizar esta firma',
+        message: 'Sólo un inspector asignado puede realizar esta operación',
       });
     }
   }

From 97a6fb029dd65c6250d6ee1aa56cba7976aceeca Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:55:14 -0300
Subject: [PATCH 021/224] refactor(f4): expose lock and seal act lifecycle

---
 .../inspection-closing.controller.ts           | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/api-v3/src/inspection-closing/inspection-closing.controller.ts b/api-v3/src/inspection-closing/inspection-closing.controller.ts
index 14e0663..ef36886 100644
--- a/api-v3/src/inspection-closing/inspection-closing.controller.ts
+++ b/api-v3/src/inspection-closing/inspection-closing.controller.ts
@@ -48,9 +48,9 @@ export class InspectionClosingController {
     return this.closing.upsertResponsible(actId, dto, principal, request);
   }
 
-  @Post('ready')
+  @Post('lock')
   @RequirePermissions('inspection_closure.prepare')
-  ready(
+  lock(
     @Param('actId', new ParseUUIDPipe({ version: '4' })) actId: string,
     @CurrentAuth() principal: AuthPrincipal,
     @Req() request: RequestWithContext,
@@ -58,16 +58,6 @@ export class InspectionClosingController {
     return this.closing.prepare(actId, principal, request);
   }
 
-  @Post('reopen')
-  @RequirePermissions('inspection_closure.prepare')
-  reopen(
-    @Param('actId', new ParseUUIDPipe({ version: '4' })) actId: string,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.closing.reopen(actId, principal, request);
-  }
-
   @Post('signatures/inspector')
   @RequirePermissions('inspection_closure.sign')
   @UseInterceptors(FileInterceptor('file', {
@@ -109,9 +99,9 @@ export class InspectionClosingController {
     return this.closing.recordCompanyOutcome(actId, dto, principal, request);
   }
 
-  @Post('close')
+  @Post('seal')
   @RequirePermissions('inspection_closure.close')
-  close(
+  seal(
     @Param('actId', new ParseUUIDPipe({ version: '4' })) actId: string,
     @Body() dto: CloseInspectionActDto,
     @CurrentAuth() principal: AuthPrincipal,

From 416aac335c0e99b40e2729e10a038e9359c8d17b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:56:11 -0300
Subject: [PATCH 022/224] refactor(f4): make INF editable and one-to-one with
 sealed Act

---
 .../inspection-reports.service.ts             | 407 ++++++++----------
 1 file changed, 178 insertions(+), 229 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-reports.service.ts b/api-v3/src/inspection-reports/inspection-reports.service.ts
index 4d7d13f..83a7f36 100644
--- a/api-v3/src/inspection-reports/inspection-reports.service.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.service.ts
@@ -5,7 +5,6 @@ import { AuditService } from '../audit/audit.service';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
 import {
   AuditAction,
-  DocumentSequenceType,
   InspectionActStatus,
   InspectionReportPdfStatus,
   InspectionReportStatus,
@@ -16,7 +15,7 @@ import type { ListInspectionReportsQueryDto } from './dto/list-inspection-report
 import { InspectionReportWordService } from './inspection-report-word.service';
 import { InspectionDocumentDeliveryService } from './inspection-document-delivery.service';
 
-const REPORT_SCHEMA_VERSION = 'DH-INSPECTION-REPORT-V1';
+const REPORT_SCHEMA_VERSION = 'DH-INSPECTION-INF-V4';
 
 interface ContextAsset {
   id: string;
@@ -32,20 +31,31 @@ export interface InspectionReportListItem {
   reportNumber: number;
   code: string;
   status: InspectionReportStatus;
+  executiveSummary: string | null;
+  reportDescription: string | null;
+  gedoIfIdentifier: string | null;
+  gedoOfficializedAt: Date | null;
+  gedoPdfOriginalName: string | null;
+  gedoPdfSha256: string | null;
   pdfStatus: InspectionReportPdfStatus;
   wordStatus: 'PENDING' | 'READY' | 'FAILED';
   wordGeneratedAt: Date | null;
-  reviewStatus: 'PENDING_REVIEW' | 'APPROVED' | 'SIGNED';
-  currentRevisionNumber: number;
-  approvedAt: Date | null;
-  signedAt: Date | null;
   title: string;
   actVersion: number;
   actClosureSha256: string;
   frozenSha256: string;
   generatedAt: Date;
   generatedBy: { id: string; username: string; firstName: string; lastName: string };
-  act: { id: string; code: string; title: string; status: string; occurredAt: Date; closedAt: Date | null };
+  act: {
+    id: string;
+    code: string;
+    title: string;
+    status: string;
+    occurredAt: Date;
+    sealedAt: Date | null;
+    urgency: string;
+    deadlineAt: Date | null;
+  };
   visit: { id: string; code: string; title: string; status: string };
   companies: ContextAsset[];
   areas: ContextAsset[];
@@ -63,7 +73,7 @@ export interface PendingInspectionReportItem {
   actTitle: string;
   actYear: number;
   occurredAt: Date;
-  closedAt: Date;
+  sealedAt: Date;
   closureSha256: string;
   visitCode: string;
   visitTitle: string;
@@ -127,7 +137,7 @@ export class InspectionReportsService {
 
   async listPending(query: ListInspectionReportsQueryDto) {
     const conditions = [
-      `act.status = 'CLOSED'`,
+      `act.status = 'SEALED'`,
       'report.id IS NULL',
       'act.closure_sha256 IS NOT NULL',
     ];
@@ -143,21 +153,6 @@ export class InspectionReportsService {
         OR act.title ILIKE ${search}
         OR visit.code ILIKE ${search}
         OR visit.title ILIKE ${search}
-        OR EXISTS (
-          SELECT 1
-          FROM inspection_act_assets search_link
-          INNER JOIN assets search_asset ON search_asset.id = search_link.asset_id
-          LEFT JOIN assets search_company ON search_company.id = search_asset.operator_company_id
-          LEFT JOIN assets search_area ON search_area.id = search_asset.operational_area_id
-          WHERE search_link.act_id = act.id
-            AND search_link.included = true
-            AND (
-              search_asset.name ILIKE ${search}
-              OR search_asset.code ILIKE ${search}
-              OR search_company.name ILIKE ${search}
-              OR search_area.name ILIKE ${search}
-            )
-        )
       )`);
     }
     if (query.year) conditions.push(`act.act_year = ${add(query.year)}`);
@@ -196,7 +191,7 @@ export class InspectionReportsService {
         act.title AS "actTitle",
         act.act_year AS "actYear",
         act.occurred_at AS "occurredAt",
-        act.closed_at AS "closedAt",
+        act.sealed_at AS "sealedAt",
         act.closure_sha256 AS "closureSha256",
         visit.code AS "visitCode",
         visit.title AS "visitTitle",
@@ -226,16 +221,7 @@ export class InspectionReportsService {
   }
 
   async get(id: string): Promise<InspectionReportView> {
-    const [report] = (await this.dataSource.query(
-      `${this.reportSelect('WHERE report.id = $1')}`,
-      [id],
-    )) as InspectionReportListItem[];
-    if (!report) throw reportNotFound();
-    const [snapshot] = (await this.dataSource.query(
-      'SELECT frozen_snapshot AS "frozenSnapshot" FROM inspection_reports WHERE id = $1',
-      [id],
-    )) as Array<{ frozenSnapshot: Record<string, unknown> }>;
-    return { ...report, frozenSnapshot: snapshot.frozenSnapshot };
+    return this.getWithManager(this.dataSource.manager, id);
   }
 
   async generate(
@@ -244,144 +230,146 @@ export class InspectionReportsService {
     request: RequestWithContext,
   ): Promise<InspectionReportView> {
     assertMobileInspector(principal);
-    const report = await this.dataSource.transaction(async (manager) => this.ensureFrozenReport(manager, actId, principal, request));
+    const report = await this.dataSource.transaction((manager) =>
+      this.ensureFrozenReport(manager, actId, principal, request),
+    );
     await this.word.ensure(report.id);
     return this.get(report.id);
   }
 
+  /**
+   * Conserva una copia interna inmutable del Acta sellada como fuente documental.
+   * El INF que se genera desde esa fuente permanece editable y versionable.
+   */
   async ensureFrozenReport(
     manager: EntityManager,
     actId: string,
     principal: AuthPrincipal,
     request: RequestWithContext,
   ): Promise<InspectionReportView> {
-      const [act] = (await manager.query(`
-        SELECT
-          act.id,
-          act.visit_id AS "visitId",
-          act.act_year AS "actYear",
-          act.code,
-          act.title,
-          act.status,
-          act.current_version AS "currentVersion",
-          act.closure_sha256 AS "closureSha256",
-          visit.code AS "visitCode",
-          visit.title AS "visitTitle"
-        FROM inspection_acts act
-        INNER JOIN inspection_visits visit ON visit.id = act.visit_id
-        WHERE act.id = $1
-        FOR UPDATE OF act
-      `, [actId])) as Array<{
-        id: string;
-        visitId: string;
-        actYear: number;
-        code: string;
-        title: string;
-        status: InspectionActStatus;
-        currentVersion: number;
-        closureSha256: string | null;
-        visitCode: string;
-        visitTitle: string;
-      }>;
-      if (!act) throw actNotFound();
-      if (act.status !== InspectionActStatus.CLOSED || !act.closureSha256) {
-        throw new ConflictException({
-          code: 'INSPECTION_REPORT_ACT_NOT_CLOSED',
-          message: 'El informe sólo puede emitirse después del cierre definitivo del acta',
-        });
-      }
-      await this.assertActorAssigned(manager, act.visitId, principal.userId);
-      const [existing] = (await manager.query(
-        'SELECT id FROM inspection_reports WHERE act_id = $1',
-        [actId],
-      )) as Array<{ id: string }>;
-      if (existing) return this.getWithManager(manager, existing.id);
-      const [closure] = (await manager.query(`
-        SELECT final_snapshot AS "finalSnapshot", final_sha256 AS "finalSha256"
-        FROM inspection_act_closures
-        WHERE act_id = $1
-      `, [actId])) as Array<{
-        finalSnapshot: Record<string, unknown> | null;
-        finalSha256: string | null;
-      }>;
-      if (!closure?.finalSnapshot || closure.finalSha256 !== act.closureSha256) {
-        throw new ConflictException({
-          code: 'INSPECTION_REPORT_CLOSURE_NOT_FROZEN',
-          message: 'El cierre del acta no tiene una instantánea final válida para emitir el informe',
-        });
-      }
-      const reportNumber = await this.allocateNumber(manager, act.actYear);
-      if (reportNumber > 999999) {
-        throw new ConflictException({
-          code: 'INSPECTION_REPORT_SEQUENCE_EXHAUSTED',
-          message: 'La numeración anual de informes agotó su rango disponible',
-        });
-      }
-      const code = `INF-${act.actYear}-${String(reportNumber).padStart(6, '0')}`;
-      const generatedAt = new Date();
-      const title = `Informe técnico · ${act.title}`.slice(0, 220);
-      const frozenSnapshot = {
-        schemaVersion: REPORT_SCHEMA_VERSION,
-        report: {
-          code,
-          reportYear: act.actYear,
-          reportNumber,
-          generatedAt: generatedAt.toISOString(),
-          generatedBy: principal.userId,
-          generatedByUsername: principal.username,
-          visitId: act.visitId,
-          visitCode: act.visitCode,
-          visitTitle: act.visitTitle,
-          actId: act.id,
-          actCode: act.code,
-          actVersion: act.currentVersion,
-          actClosureSha256: act.closureSha256,
-        },
-        actClosure: closure.finalSnapshot,
-      };
-      const frozenSha256 = sha256CanonicalJson(frozenSnapshot);
-      const [created] = (await manager.query(`
-        INSERT INTO inspection_reports (
-          visit_id, act_id, report_year, report_number, code, status, pdf_status,
-          title, act_version, act_closure_sha256, frozen_sha256, frozen_snapshot,
-          generated_at, generated_by
-        ) VALUES (
-          $1, $2, $3, $4, $5, 'FROZEN', 'PENDING', $6, $7, $8, $9, $10, $11, $12
-        )
-        RETURNING id
-      `, [
-        act.visitId,
+    const [act] = (await manager.query(`
+      SELECT
         act.id,
-        act.actYear,
-        reportNumber,
+        act.visit_id AS "visitId",
+        act.act_year AS "actYear",
+        act.act_number AS "actNumber",
+        act.code,
+        act.title,
+        act.status,
+        act.current_version AS "currentVersion",
+        act.closure_sha256 AS "closureSha256",
+        act.occurred_at AS "occurredAt",
+        visit.code AS "visitCode",
+        visit.title AS "visitTitle"
+      FROM inspection_acts act
+      INNER JOIN inspection_visits visit ON visit.id = act.visit_id
+      WHERE act.id = $1
+      FOR UPDATE OF act
+    `, [actId])) as Array<{
+      id: string;
+      visitId: string;
+      actYear: number;
+      actNumber: number;
+      code: string;
+      title: string;
+      status: InspectionActStatus;
+      currentVersion: number;
+      closureSha256: string | null;
+      occurredAt: Date;
+      visitCode: string;
+      visitTitle: string;
+    }>;
+    if (!act) throw actNotFound();
+    if (act.status !== InspectionActStatus.SEALED || !act.closureSha256) {
+      throw new ConflictException({
+        code: 'INSPECTION_REPORT_ACT_NOT_SEALED',
+        message: 'El INF sólo puede generarse después de sellar el acta',
+      });
+    }
+    await this.assertActorAssigned(manager, act.visitId, principal.userId);
+    const [existing] = (await manager.query(
+      'SELECT id FROM inspection_reports WHERE act_id = $1',
+      [actId],
+    )) as Array<{ id: string }>;
+    if (existing) return this.getWithManager(manager, existing.id);
+
+    const [closure] = (await manager.query(`
+      SELECT final_snapshot AS "finalSnapshot", final_sha256 AS "finalSha256"
+      FROM inspection_act_closures
+      WHERE act_id = $1
+    `, [actId])) as Array<{
+      finalSnapshot: Record<string, unknown> | null;
+      finalSha256: string | null;
+    }>;
+    if (!closure?.finalSnapshot || closure.finalSha256 !== act.closureSha256) {
+      throw new ConflictException({
+        code: 'INSPECTION_REPORT_ACT_SNAPSHOT_INVALID',
+        message: 'El acta sellada no tiene una instantánea final válida',
+      });
+    }
+
+    const reportNumber = act.actNumber;
+    const code = act.code.replace(/^ACT-/, 'INF-');
+    const generatedAt = new Date();
+    const title = `Informe de inspección · ${act.code}`.slice(0, 220);
+    const frozenSnapshot = {
+      schemaVersion: REPORT_SCHEMA_VERSION,
+      source: {
+        actId: act.id,
+        actCode: act.code,
+        actVersion: act.currentVersion,
+        actClosureSha256: act.closureSha256,
+        inspectionId: act.visitId,
+        inspectionCode: act.visitCode,
+      },
+      sealedAct: closure.finalSnapshot,
+    };
+    const frozenSha256 = sha256CanonicalJson(frozenSnapshot);
+    const [created] = (await manager.query(`
+      INSERT INTO inspection_reports (
+        visit_id,act_id,report_year,report_number,code,status,pdf_status,
+        executive_summary,report_description,title,act_version,act_closure_sha256,
+        frozen_sha256,frozen_snapshot,generated_at,generated_by
+      ) VALUES (
+        $1,$2,$3,$4,$5,'WORKING','PENDING',NULL,NULL,$6,$7,$8,$9,$10,$11,$12
+      )
+      RETURNING id
+    `, [
+      act.visitId,
+      act.id,
+      act.actYear,
+      reportNumber,
+      code,
+      title,
+      act.currentVersion,
+      act.closureSha256,
+      frozenSha256,
+      frozenSnapshot,
+      generatedAt,
+      principal.userId,
+    ])) as Array<{ id: string }>;
+    await this.audit.record({
+      ...administrationAuditContext(principal, request),
+      action: AuditAction.INSPECTION_REPORT_GENERATED,
+      entityType: 'inspection_report',
+      entityId: created.id,
+      afterData: {
         code,
-        title,
-        act.currentVersion,
-        act.closureSha256,
+        actId: act.id,
+        inspectionId: act.visitId,
+        actVersion: act.currentVersion,
         frozenSha256,
-        frozenSnapshot,
-        generatedAt,
-        principal.userId,
-      ])) as Array<{ id: string }>;
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_REPORT_GENERATED,
-        entityType: 'inspection_report',
-        entityId: created.id,
-        afterData: {
-          code,
-          actId: act.id,
-          visitId: act.visitId,
-          actVersion: act.currentVersion,
-          frozenSha256,
-          pdfStatus: InspectionReportPdfStatus.PENDING,
-        },
-      }, manager);
-      return this.getWithManager(manager, created.id);
+        status: InspectionReportStatus.WORKING,
+      },
+    }, manager);
+    return this.getWithManager(manager, created.id);
   }
 
   async ensureWordForAct(actId: string): Promise<void> {
-    const [row] = await this.dataSource.query('SELECT id FROM inspection_reports WHERE act_id = $1', [actId]) as Array<{ id: string }>;
+    const [row] = await this.dataSource.query(
+      'SELECT id FROM inspection_reports WHERE act_id = $1',
+      [actId],
+    ) as Array<{ id: string }>;
     if (row) await this.word.ensure(row.id);
     await this.delivery.dispatchForAct(actId).catch(() => undefined);
   }
@@ -398,25 +386,11 @@ export class InspectionReportsService {
       conditions.push(`(
         report.code ILIKE ${search}
         OR report.title ILIKE ${search}
+        OR report.gedo_if_identifier ILIKE ${search}
         OR act.code ILIKE ${search}
         OR act.title ILIKE ${search}
         OR visit.code ILIKE ${search}
         OR visit.title ILIKE ${search}
-        OR EXISTS (
-          SELECT 1
-          FROM inspection_act_assets search_link
-          INNER JOIN assets search_asset ON search_asset.id = search_link.asset_id
-          LEFT JOIN assets search_company ON search_company.id = search_asset.operator_company_id
-          LEFT JOIN assets search_area ON search_area.id = search_asset.operational_area_id
-          WHERE search_link.act_id = act.id
-            AND search_link.included = true
-            AND (
-              search_asset.name ILIKE ${search}
-              OR search_asset.code ILIKE ${search}
-              OR search_company.name ILIKE ${search}
-              OR search_area.name ILIKE ${search}
-            )
-        )
       )`);
     }
     if (query.year) conditions.push(`report.report_year = ${add(query.year)}`);
@@ -454,20 +428,16 @@ export class InspectionReportsService {
     return `
       SELECT
         COALESCE(JSONB_AGG(DISTINCT JSONB_BUILD_OBJECT(
-          'id', company.id,
-          'code', company.code,
-          'name', company.name
-        )) FILTER (WHERE company.id IS NOT NULL), '[]'::jsonb) AS companies,
+          'id',company.id,'code',company.code,'name',company.name
+        )) FILTER (WHERE company.id IS NOT NULL),'[]'::jsonb) AS companies,
         COALESCE(JSONB_AGG(DISTINCT JSONB_BUILD_OBJECT(
-          'id', area.id,
-          'code', area.code,
-          'name', area.name
-        )) FILTER (WHERE area.id IS NOT NULL), '[]'::jsonb) AS areas
+          'id',area.id,'code',area.code,'name',area.name
+        )) FILTER (WHERE area.id IS NOT NULL),'[]'::jsonb) AS areas
       FROM inspection_act_assets context_link
-      INNER JOIN assets context_asset ON context_asset.id = context_link.asset_id
-      LEFT JOIN assets company ON company.id = context_asset.operator_company_id
-      LEFT JOIN assets area ON area.id = context_asset.operational_area_id
-      WHERE context_link.act_id = act.id AND context_link.included = true
+      INNER JOIN assets context_asset ON context_asset.id=context_link.asset_id
+      LEFT JOIN assets company ON company.id=context_asset.operator_company_id
+      LEFT JOIN assets area ON area.id=context_asset.operational_area_id
+      WHERE context_link.act_id=act.id AND context_link.included=true
     `;
   }
 
@@ -481,50 +451,43 @@ export class InspectionReportsService {
         report.report_number AS "reportNumber",
         report.code,
         report.status,
+        report.executive_summary AS "executiveSummary",
+        report.report_description AS "reportDescription",
+        report.gedo_if_identifier AS "gedoIfIdentifier",
+        report.gedo_officialized_at AS "gedoOfficializedAt",
+        report.gedo_pdf_original_name AS "gedoPdfOriginalName",
+        report.gedo_pdf_sha256 AS "gedoPdfSha256",
         report.pdf_status AS "pdfStatus",
         report.word_status AS "wordStatus",
         report.word_generated_at AS "wordGeneratedAt",
-        report.review_status AS "reviewStatus",
-        report.current_revision_number AS "currentRevisionNumber",
-        report.approved_at AS "approvedAt",
-        report.signed_at AS "signedAt",
         report.title,
         report.act_version AS "actVersion",
         report.act_closure_sha256 AS "actClosureSha256",
         report.frozen_sha256 AS "frozenSha256",
         report.generated_at AS "generatedAt",
         JSONB_BUILD_OBJECT(
-          'id', generator.id,
-          'username', generator.username,
-          'firstName', generator.first_name,
-          'lastName', generator.last_name
+          'id',generator.id,'username',generator.username,
+          'firstName',generator.first_name,'lastName',generator.last_name
         ) AS "generatedBy",
         JSONB_BUILD_OBJECT(
-          'id', act.id,
-          'code', act.code,
-          'title', act.title,
-          'status', act.status,
-          'occurredAt', act.occurred_at,
-          'closedAt', act.closed_at
+          'id',act.id,'code',act.code,'title',act.title,'status',act.status,
+          'occurredAt',act.occurred_at,'sealedAt',act.sealed_at,
+          'urgency',act.urgency,'deadlineAt',act.deadline_at
         ) AS act,
         JSONB_BUILD_OBJECT(
-          'id', visit.id,
-          'code', visit.code,
-          'title', visit.title,
-          'status', visit.status
+          'id',visit.id,'code',visit.code,'title',visit.title,'status',visit.status
         ) AS visit,
-        COALESCE(context.companies, '[]'::jsonb) AS companies,
-        COALESCE(context.areas, '[]'::jsonb) AS areas,
-        COALESCE(finding_count.total, 0)::integer AS "findingCount"
+        COALESCE(context.companies,'[]'::jsonb) AS companies,
+        COALESCE(context.areas,'[]'::jsonb) AS areas,
+        COALESCE(finding_count.total,0)::integer AS "findingCount"
       FROM inspection_reports report
-      INNER JOIN inspection_acts act ON act.id = report.act_id
-      INNER JOIN inspection_visits visit ON visit.id = report.visit_id
-      INNER JOIN users generator ON generator.id = report.generated_by
+      INNER JOIN inspection_acts act ON act.id=report.act_id
+      INNER JOIN inspection_visits visit ON visit.id=report.visit_id
+      INNER JOIN users generator ON generator.id=report.generated_by
       LEFT JOIN LATERAL (${this.contextSelect()}) context ON true
       LEFT JOIN LATERAL (
-        SELECT COUNT(*) AS total
-        FROM inspection_findings finding
-        WHERE finding.act_id = act.id AND finding.status <> 'VOIDED'
+        SELECT COUNT(*) AS total FROM inspection_findings finding
+        WHERE finding.act_id=act.id AND finding.status<>'VOIDED'
       ) finding_count ON true
       ${where}
     `;
@@ -543,29 +506,15 @@ export class InspectionReportsService {
     return { ...report, frozenSnapshot: snapshot.frozenSnapshot };
   }
 
-  private async allocateNumber(manager: EntityManager, year: number): Promise<number> {
-    const [row] = (await manager.query(`
-      INSERT INTO document_annual_sequences (document_type, year, last_number)
-      VALUES ($1, $2, 1)
-      ON CONFLICT (document_type, year) DO UPDATE SET
-        last_number = document_annual_sequences.last_number + 1,
-        updated_at = CURRENT_TIMESTAMP
-      RETURNING last_number AS number
-    `, [DocumentSequenceType.REPORT, year])) as Array<{ number: number }>;
-    return Number(row.number);
-  }
-
   private async assertActorAssigned(manager: EntityManager, visitId: string, userId: string): Promise<void> {
     const rows = (await manager.query(`
-      SELECT 1
-      FROM inspection_visit_members
-      WHERE visit_id = $1 AND user_id = $2 AND included = true
-      LIMIT 1
+      SELECT 1 FROM inspection_visit_members
+      WHERE visit_id=$1 AND user_id=$2 AND included=true LIMIT 1
     `, [visitId, userId])) as unknown[];
-    if (rows.length === 0) {
+    if (!rows.length) {
       throw new ForbiddenException({
         code: 'INSPECTION_REPORT_ACTOR_NOT_ASSIGNED',
-        message: 'Sólo un inspector asignado a la visita puede solicitar el informe',
+        message: 'Sólo un inspector asignado a la inspección puede solicitar el informe',
       });
     }
   }

From b8fde4c32dd9d690230b2e4d668004866331f855 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:56:27 -0300
Subject: [PATCH 023/224] feat(f4): add editable INF narrative DTO

---
 .../dto/update-inspection-report.dto.ts          | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/dto/update-inspection-report.dto.ts

diff --git a/api-v3/src/inspection-reports/dto/update-inspection-report.dto.ts b/api-v3/src/inspection-reports/dto/update-inspection-report.dto.ts
new file mode 100644
index 0000000..dc73883
--- /dev/null
+++ b/api-v3/src/inspection-reports/dto/update-inspection-report.dto.ts
@@ -0,0 +1,16 @@
+import { Transform } from 'class-transformer';
+import { IsOptional, IsString, MaxLength } from 'class-validator';
+
+export class UpdateInspectionReportDto {
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() || null : value)
+  @IsString()
+  @MaxLength(20000)
+  executiveSummary?: string | null;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() || null : value)
+  @IsString()
+  @MaxLength(40000)
+  description?: string | null;
+}

From 0c35e801eb6c3795c25a2dd6060774537060f6a0 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:56:32 -0300
Subject: [PATCH 024/224] feat(f4): add GEDO officialization DTO

---
 .../dto/officialize-inspection-report.dto.ts        | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/dto/officialize-inspection-report.dto.ts

diff --git a/api-v3/src/inspection-reports/dto/officialize-inspection-report.dto.ts b/api-v3/src/inspection-reports/dto/officialize-inspection-report.dto.ts
new file mode 100644
index 0000000..d11e599
--- /dev/null
+++ b/api-v3/src/inspection-reports/dto/officialize-inspection-report.dto.ts
@@ -0,0 +1,13 @@
+import { Transform } from 'class-transformer';
+import { IsISO8601, IsString, MaxLength, MinLength } from 'class-validator';
+
+export class OfficializeInspectionReportDto {
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(255)
+  gedoIfIdentifier!: string;
+
+  @IsISO8601({ strict: true })
+  gedoOfficializedAt!: string;
+}

From ad66bb3e6196f304ab1eb8800b15bbcb4d1dd8c6 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:56:39 -0300
Subject: [PATCH 025/224] feat(f4): add append-only INF follow-up DTO

---
 .../create-inspection-report-follow-up.dto.ts | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/dto/create-inspection-report-follow-up.dto.ts

diff --git a/api-v3/src/inspection-reports/dto/create-inspection-report-follow-up.dto.ts b/api-v3/src/inspection-reports/dto/create-inspection-report-follow-up.dto.ts
new file mode 100644
index 0000000..e777ba7
--- /dev/null
+++ b/api-v3/src/inspection-reports/dto/create-inspection-report-follow-up.dto.ts
@@ -0,0 +1,23 @@
+import { Transform } from 'class-transformer';
+import { IsEnum, IsISO8601, IsOptional, IsString, MaxLength } from 'class-validator';
+import { InspectionReportFollowUpType } from '../../database/entities';
+
+export class CreateInspectionReportFollowUpDto {
+  @IsEnum(InspectionReportFollowUpType)
+  type!: InspectionReportFollowUpType;
+
+  @IsISO8601({ strict: true })
+  occurredAt!: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() || null : value)
+  @IsString()
+  @MaxLength(255)
+  externalReference?: string | null;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() || null : value)
+  @IsString()
+  @MaxLength(20000)
+  description?: string | null;
+}

From 31256ea0b5f2a99885fb18c8057b0f40f897f3d9 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:57:22 -0300
Subject: [PATCH 026/224] feat(f4): implement INF editing, GEDO officialization
 and follow-up

---
 .../inspection-report-workflow.service.ts     | 433 ++++++++++++++++++
 1 file changed, 433 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/inspection-report-workflow.service.ts

diff --git a/api-v3/src/inspection-reports/inspection-report-workflow.service.ts b/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
new file mode 100644
index 0000000..41d06d3
--- /dev/null
+++ b/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
@@ -0,0 +1,433 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import { isAbsolute, parse, resolve } from 'node:path';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  InternalServerErrorException,
+  NotFoundException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DataSource, EntityManager } from 'typeorm';
+import { administrationAuditContext } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import {
+  AuditAction,
+  InspectionActUrgency,
+  InspectionDeadlineBasis,
+  InspectionDeadlineDayType,
+  InspectionReportStatus,
+} from '../database/entities';
+import type { CreateInspectionReportFollowUpDto } from './dto/create-inspection-report-follow-up.dto';
+import type { OfficializeInspectionReportDto } from './dto/officialize-inspection-report.dto';
+import type { UpdateInspectionReportDto } from './dto/update-inspection-report.dto';
+
+export const MAX_INSPECTION_REPORT_FILE_BYTES = 40 * 1024 * 1024;
+
+export interface UploadedInspectionReportFile {
+  buffer: Buffer;
+  originalname: string;
+  mimetype: string;
+  size: number;
+}
+
+interface ReportRow {
+  id: string;
+  actId: string;
+  visitId: string;
+  code: string;
+  status: InspectionReportStatus;
+  executiveSummary: string | null;
+  reportDescription: string | null;
+  gedoIfIdentifier: string | null;
+  gedoOfficializedAt: Date | null;
+}
+
+function reportNotFound(): NotFoundException {
+  return new NotFoundException({
+    code: 'INSPECTION_REPORT_NOT_FOUND',
+    message: 'Informe de inspección no encontrado',
+  });
+}
+
+@Injectable()
+export class InspectionReportWorkflowService {
+  private readonly root: string;
+
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly audit: AuditService,
+    config: ConfigService,
+  ) {
+    const configured = config.get<string>('INSPECTION_REPORT_UPLOAD_ROOT')
+      ?? '/app/storage/inspection-reports';
+    if (!isAbsolute(configured)) throw new Error('INSPECTION_REPORT_UPLOAD_ROOT must be absolute');
+    this.root = resolve(configured);
+    if (this.root === parse(this.root).root) {
+      throw new Error('INSPECTION_REPORT_UPLOAD_ROOT cannot be filesystem root');
+    }
+  }
+
+  async updateNarrative(
+    reportId: string,
+    dto: UpdateInspectionReportDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    if (Object.keys(dto).length === 0) {
+      throw new BadRequestException({ code: 'NO_CHANGES', message: 'No se recibieron cambios' });
+    }
+    return this.dataSource.transaction(async (manager) => {
+      const report = await this.lockReport(manager, reportId);
+      if (report.status !== InspectionReportStatus.WORKING) {
+        throw new ConflictException({
+          code: 'INSPECTION_REPORT_ALREADY_OFFICIALIZED',
+          message: 'El contenido editable del INF queda cerrado cuando se registra su IF oficial de GEDO',
+        });
+      }
+      const before = {
+        executiveSummary: report.executiveSummary,
+        reportDescription: report.reportDescription,
+      };
+      const executiveSummary = dto.executiveSummary !== undefined
+        ? dto.executiveSummary
+        : report.executiveSummary;
+      const reportDescription = dto.description !== undefined
+        ? dto.description
+        : report.reportDescription;
+      await manager.query(`
+        UPDATE inspection_reports
+        SET executive_summary=$2,
+            report_description=$3,
+            updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1
+      `, [reportId, executiveSummary, reportDescription]);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_REPORT_UPDATED,
+        entityType: 'inspection_report',
+        entityId: reportId,
+        beforeData: before,
+        afterData: { executiveSummary, reportDescription },
+        metadata: { reportCode: report.code, actId: report.actId },
+      }, manager);
+      return this.getWorkflowView(manager, reportId);
+    });
+  }
+
+  async officialize(
+    reportId: string,
+    dto: OfficializeInspectionReportDto,
+    file: UploadedInspectionReportFile | undefined,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    this.assertPdf(file);
+    const id = randomUUID();
+    const storedName = `gedo-${id}.pdf`;
+    const filePath = resolve(this.root, storedName);
+    const sha256 = createHash('sha256').update(file!.buffer).digest('hex');
+    await mkdir(this.root, { recursive: true, mode: 0o700 });
+    await writeFile(filePath, file!.buffer, { flag: 'wx', mode: 0o600 });
+    try {
+      return await this.dataSource.transaction(async (manager) => {
+        const report = await this.lockReport(manager, reportId);
+        if (report.status !== InspectionReportStatus.WORKING) {
+          throw new ConflictException({
+            code: 'INSPECTION_REPORT_ALREADY_OFFICIALIZED',
+            message: 'El IF oficial de GEDO ya fue registrado y es inmutable',
+          });
+        }
+        const officializedAt = new Date(dto.gedoOfficializedAt);
+        const now = new Date();
+        if (officializedAt.getTime() > now.getTime() + 24 * 60 * 60 * 1000) {
+          throw new BadRequestException({
+            code: 'INVALID_GEDO_DATE',
+            message: 'La fecha de GEDO no puede estar más de 24 horas en el futuro',
+          });
+        }
+        await manager.query(`
+          UPDATE inspection_reports
+          SET status='OFFICIALIZED',
+              gedo_if_identifier=$2,
+              gedo_officialized_at=$3,
+              gedo_pdf_original_name=$4,
+              gedo_pdf_stored_name=$5,
+              gedo_pdf_mime_type='application/pdf',
+              gedo_pdf_size_bytes=$6,
+              gedo_pdf_sha256=$7,
+              updated_at=CURRENT_TIMESTAMP
+          WHERE id=$1
+        `, [
+          reportId,
+          dto.gedoIfIdentifier,
+          officializedAt,
+          file!.originalname,
+          storedName,
+          file!.buffer.length,
+          sha256,
+        ]);
+        await this.activateNonUrgentDeadline(manager, report.actId, officializedAt);
+        await this.audit.record({
+          ...administrationAuditContext(principal, request),
+          action: AuditAction.INSPECTION_REPORT_OFFICIALIZED,
+          entityType: 'inspection_report',
+          entityId: reportId,
+          afterData: {
+            status: InspectionReportStatus.OFFICIALIZED,
+            gedoIfIdentifier: dto.gedoIfIdentifier,
+            gedoOfficializedAt: officializedAt,
+            gedoPdfOriginalName: file!.originalname,
+            gedoPdfSha256: sha256,
+          },
+          metadata: { reportCode: report.code, actId: report.actId, immutable: true },
+        }, manager);
+        return this.getWorkflowView(manager, reportId);
+      });
+    } catch (error) {
+      await unlink(filePath).catch(() => undefined);
+      throw error;
+    }
+  }
+
+  async addFollowUp(
+    reportId: string,
+    dto: CreateInspectionReportFollowUpDto,
+    file: UploadedInspectionReportFile | undefined,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    if (file && file.buffer.length > MAX_INSPECTION_REPORT_FILE_BYTES) {
+      throw new BadRequestException({
+        code: 'INSPECTION_REPORT_FILE_TOO_LARGE',
+        message: 'El archivo supera el máximo permitido de 40 MB',
+      });
+    }
+    const followUpId = randomUUID();
+    const ext = this.safeExtension(file?.originalname);
+    const storedName = file ? `followup-${followUpId}${ext}` : null;
+    const filePath = storedName ? resolve(this.root, storedName) : null;
+    const sha256 = file ? createHash('sha256').update(file.buffer).digest('hex') : null;
+    if (filePath && file) {
+      await mkdir(this.root, { recursive: true, mode: 0o700 });
+      await writeFile(filePath, file.buffer, { flag: 'wx', mode: 0o600 });
+    }
+    try {
+      return await this.dataSource.transaction(async (manager) => {
+        const report = await this.lockReport(manager, reportId);
+        const occurredAt = new Date(dto.occurredAt);
+        await manager.query(`
+          INSERT INTO inspection_report_follow_ups (
+            id,report_id,type,external_reference,occurred_at,description,
+            original_name,stored_name,mime_type,size_bytes,sha256,created_by
+          ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)
+        `, [
+          followUpId,
+          reportId,
+          dto.type,
+          dto.externalReference ?? null,
+          occurredAt,
+          dto.description ?? null,
+          file?.originalname ?? null,
+          storedName,
+          file?.mimetype ?? null,
+          file?.buffer.length ?? null,
+          sha256,
+          principal.userId,
+        ]);
+        await this.audit.record({
+          ...administrationAuditContext(principal, request),
+          action: AuditAction.INSPECTION_REPORT_FOLLOW_UP_ADDED,
+          entityType: 'inspection_report_follow_up',
+          entityId: followUpId,
+          afterData: {
+            reportId,
+            type: dto.type,
+            externalReference: dto.externalReference ?? null,
+            occurredAt,
+            description: dto.description ?? null,
+            originalName: file?.originalname ?? null,
+            sha256,
+          },
+          metadata: { reportCode: report.code, actId: report.actId, appendOnly: true },
+        }, manager);
+        return this.listFollowUpsWithManager(manager, reportId);
+      });
+    } catch (error) {
+      if (filePath) await unlink(filePath).catch(() => undefined);
+      throw error;
+    }
+  }
+
+  async listFollowUps(reportId: string) {
+    const report = await this.getReport(this.dataSource.manager, reportId);
+    if (!report) throw reportNotFound();
+    return this.listFollowUpsWithManager(this.dataSource.manager, reportId);
+  }
+
+  private async listFollowUpsWithManager(manager: EntityManager, reportId: string) {
+    return manager.query(`
+      SELECT
+        follow_up.id,
+        follow_up.report_id AS "reportId",
+        follow_up.type,
+        follow_up.external_reference AS "externalReference",
+        follow_up.occurred_at AS "occurredAt",
+        follow_up.description,
+        follow_up.original_name AS "originalName",
+        follow_up.mime_type AS "mimeType",
+        follow_up.size_bytes AS "sizeBytes",
+        follow_up.sha256,
+        follow_up.created_by AS "createdBy",
+        follow_up.created_at AS "createdAt"
+      FROM inspection_report_follow_ups follow_up
+      WHERE follow_up.report_id=$1
+      ORDER BY follow_up.occurred_at,follow_up.created_at,follow_up.id
+    `, [reportId]);
+  }
+
+  private async activateNonUrgentDeadline(
+    manager: EntityManager,
+    actId: string,
+    officializedAt: Date,
+  ): Promise<void> {
+    const [act] = await manager.query(`
+      SELECT urgency,deadline_days AS "deadlineDays",deadline_day_type AS "deadlineDayType",
+             deadline_basis AS "deadlineBasis",deadline_at AS "deadlineAt"
+      FROM inspection_acts WHERE id=$1 FOR UPDATE
+    `, [actId]) as Array<{
+      urgency: InspectionActUrgency;
+      deadlineDays: number | null;
+      deadlineDayType: InspectionDeadlineDayType | null;
+      deadlineBasis: InspectionDeadlineBasis | null;
+      deadlineAt: Date | null;
+    }>;
+    if (!act) return;
+    if (act.urgency !== InspectionActUrgency.NON_URGENT) return;
+    if (act.deadlineBasis !== InspectionDeadlineBasis.GEDO_DATE) {
+      throw new ConflictException({
+        code: 'INVALID_NON_URGENT_DEADLINE_BASIS',
+        message: 'El acta no urgente no conserva la regla GEDO necesaria para calcular su vencimiento',
+      });
+    }
+    if (!act.deadlineDays || !act.deadlineDayType) {
+      throw new ConflictException({
+        code: 'MISSING_ACT_DEADLINE_SNAPSHOT',
+        message: 'El acta no conserva la política de plazo aplicada al momento de finalizarse',
+      });
+    }
+    const deadlineAt = await this.calculateDeadline(
+      manager,
+      officializedAt,
+      Number(act.deadlineDays),
+      act.deadlineDayType,
+    );
+    await manager.query(`
+      UPDATE inspection_acts
+      SET deadline_base_at=$2,deadline_at=$3,updated_at=CURRENT_TIMESTAMP
+      WHERE id=$1
+    `, [actId, officializedAt, deadlineAt]);
+  }
+
+  private async calculateDeadline(
+    manager: EntityManager,
+    baseAt: Date,
+    days: number,
+    dayType: InspectionDeadlineDayType,
+  ): Promise<Date> {
+    if (dayType === InspectionDeadlineDayType.CALENDAR) {
+      const [row] = await manager.query(`
+        SELECT (
+          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + $2::integer)::timestamp
+          + time '23:59:59'
+        ) AT TIME ZONE 'America/Argentina/Mendoza' AS due_at
+      `, [baseAt, days]) as Array<{ due_at: Date }>;
+      return row.due_at;
+    }
+    const [row] = await manager.query(`
+      WITH candidates AS (
+        SELECT day::date AS day,
+          COALESCE(override.is_business_day, EXTRACT(ISODOW FROM day)::integer BETWEEN 1 AND 5) AS business
+        FROM generate_series(
+          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + 1)::timestamp,
+          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + 730)::timestamp,
+          interval '1 day'
+        ) day
+        LEFT JOIN inspection_business_calendar_days override ON override.date=day::date
+      ), ranked AS (
+        SELECT day,ROW_NUMBER() OVER (ORDER BY day) AS position FROM candidates WHERE business=true
+      )
+      SELECT ((day::timestamp + time '23:59:59') AT TIME ZONE 'America/Argentina/Mendoza') AS due_at
+      FROM ranked WHERE position=$2 LIMIT 1
+    `, [baseAt, days]) as Array<{ due_at: Date }>;
+    if (!row?.due_at) throw new InternalServerErrorException('No se pudo calcular el vencimiento');
+    return row.due_at;
+  }
+
+  private assertPdf(file: UploadedInspectionReportFile | undefined): void {
+    if (!file?.buffer?.length) {
+      throw new BadRequestException({
+        code: 'GEDO_PDF_REQUIRED',
+        message: 'Debe adjuntarse el PDF oficial generado por GEDO',
+      });
+    }
+    if (file.buffer.length > MAX_INSPECTION_REPORT_FILE_BYTES) {
+      throw new BadRequestException({
+        code: 'GEDO_PDF_TOO_LARGE',
+        message: 'El PDF oficial supera el máximo permitido de 40 MB',
+      });
+    }
+    if (file.mimetype !== 'application/pdf' || file.buffer.subarray(0, 5).toString('ascii') !== '%PDF-') {
+      throw new BadRequestException({
+        code: 'INVALID_GEDO_PDF',
+        message: 'El documento oficial de GEDO debe ser un PDF válido',
+      });
+    }
+  }
+
+  private safeExtension(name: string | undefined): string {
+    if (!name) return '';
+    const dot = name.lastIndexOf('.');
+    if (dot < 0) return '';
+    const ext = name.slice(dot).toLowerCase();
+    return /^\.[a-z0-9]{1,10}$/.test(ext) ? ext : '';
+  }
+
+  private async lockReport(manager: EntityManager, id: string): Promise<ReportRow> {
+    const [row] = await manager.query(`
+      SELECT id,act_id AS "actId",visit_id AS "visitId",code,status,
+        executive_summary AS "executiveSummary",report_description AS "reportDescription",
+        gedo_if_identifier AS "gedoIfIdentifier",gedo_officialized_at AS "gedoOfficializedAt"
+      FROM inspection_reports WHERE id=$1 FOR UPDATE
+    `, [id]) as ReportRow[];
+    if (!row) throw reportNotFound();
+    return row;
+  }
+
+  private async getReport(manager: EntityManager, id: string): Promise<ReportRow | null> {
+    const [row] = await manager.query(`
+      SELECT id,act_id AS "actId",visit_id AS "visitId",code,status,
+        executive_summary AS "executiveSummary",report_description AS "reportDescription",
+        gedo_if_identifier AS "gedoIfIdentifier",gedo_officialized_at AS "gedoOfficializedAt"
+      FROM inspection_reports WHERE id=$1
+    `, [id]) as ReportRow[];
+    return row ?? null;
+  }
+
+  private async getWorkflowView(manager: EntityManager, id: string) {
+    const report = await this.getReport(manager, id);
+    if (!report) throw reportNotFound();
+    const [act] = await manager.query(`
+      SELECT code,urgency,deadline_days AS "deadlineDays",deadline_day_type AS "deadlineDayType",
+        deadline_basis AS "deadlineBasis",deadline_base_at AS "deadlineBaseAt",deadline_at AS "deadlineAt"
+      FROM inspection_acts WHERE id=$1
+    `, [report.actId]);
+    return {
+      ...report,
+      act,
+      followUps: await this.listFollowUpsWithManager(manager, id),
+    };
+  }
+}

From 39846c81a483d2b62bdcad2f887bff8be846a06c Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:57:37 -0300
Subject: [PATCH 027/224] feat(f4): expose INF editing, GEDO and follow-up
 endpoints

---
 .../inspection-reports.controller.ts          | 77 ++++++++++++++++++-
 1 file changed, 75 insertions(+), 2 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-reports.controller.ts b/api-v3/src/inspection-reports/inspection-reports.controller.ts
index 536a543..3f44101 100644
--- a/api-v3/src/inspection-reports/inspection-reports.controller.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.controller.ts
@@ -1,15 +1,41 @@
-import { Controller, Get, Param, ParseUUIDPipe, Post, Query, Req, Res } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Query,
+  Req,
+  Res,
+  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 type { Response } from 'express';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { CreateInspectionReportFollowUpDto } from './dto/create-inspection-report-follow-up.dto';
 import { ListInspectionReportsQueryDto } from './dto/list-inspection-reports-query.dto';
+import { OfficializeInspectionReportDto } from './dto/officialize-inspection-report.dto';
+import { UpdateInspectionReportDto } from './dto/update-inspection-report.dto';
+import {
+  InspectionReportWorkflowService,
+  MAX_INSPECTION_REPORT_FILE_BYTES,
+  type UploadedInspectionReportFile,
+} from './inspection-report-workflow.service';
 import { InspectionReportsService } from './inspection-reports.service';
 import { InspectionReportWordService } from './inspection-report-word.service';
 
 @Controller('inspection-reports')
 export class InspectionReportsController {
-  constructor(private readonly reports: InspectionReportsService, private readonly word: InspectionReportWordService) {}
+  constructor(
+    private readonly reports: InspectionReportsService,
+    private readonly word: InspectionReportWordService,
+    private readonly workflow: InspectionReportWorkflowService,
+  ) {}
 
   @Get()
   @RequirePermissions('inspection_reports.read')
@@ -42,6 +68,53 @@ export class InspectionReportsController {
     return response.sendFile(content.filePath);
   }
 
+  @Patch(':id')
+  @RequirePermissions('inspection_reports.generate')
+  updateNarrative(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Body() dto: UpdateInspectionReportDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.workflow.updateNarrative(id, dto, principal, request);
+  }
+
+  @Post(':id/officialize')
+  @RequirePermissions('inspection_reports.generate')
+  @UseInterceptors(FileInterceptor('file', {
+    limits: { fileSize: MAX_INSPECTION_REPORT_FILE_BYTES, files: 1 },
+  }))
+  officialize(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Body() dto: OfficializeInspectionReportDto,
+    @UploadedFile() file: UploadedInspectionReportFile | undefined,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.workflow.officialize(id, dto, file, principal, request);
+  }
+
+  @Get(':id/follow-ups')
+  @RequirePermissions('inspection_reports.read')
+  followUps(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
+    return this.workflow.listFollowUps(id);
+  }
+
+  @Post(':id/follow-ups')
+  @RequirePermissions('inspection_reports.generate')
+  @UseInterceptors(FileInterceptor('file', {
+    limits: { fileSize: MAX_INSPECTION_REPORT_FILE_BYTES, files: 1 },
+  }))
+  addFollowUp(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Body() dto: CreateInspectionReportFollowUpDto,
+    @UploadedFile() file: UploadedInspectionReportFile | undefined,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.workflow.addFollowUp(id, dto, file, principal, request);
+  }
+
   @Get(':id')
   @RequirePermissions('inspection_reports.read')
   get(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {

From a1d994b6d469e3f18a70535999412a98578607a3 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:57:47 -0300
Subject: [PATCH 028/224] feat(f4): register INF workflow service

---
 api-v3/src/inspection-reports/inspection-reports.module.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/api-v3/src/inspection-reports/inspection-reports.module.ts b/api-v3/src/inspection-reports/inspection-reports.module.ts
index 3ef820c..ff43f14 100644
--- a/api-v3/src/inspection-reports/inspection-reports.module.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.module.ts
@@ -3,6 +3,7 @@ import { AuditModule } from '../audit/audit.module';
 import { DocumentDeliveryController } from './document-delivery.controller';
 import { InspectionActPdfService } from './inspection-act-pdf.service';
 import { InspectionDocumentDeliveryService } from './inspection-document-delivery.service';
+import { InspectionReportWorkflowService } from './inspection-report-workflow.service';
 import { InspectionReportWordService } from './inspection-report-word.service';
 import { InspectionActReportController, InspectionReportsController } from './inspection-reports.controller';
 import { InspectionReportsService } from './inspection-reports.service';
@@ -17,6 +18,7 @@ import { SmtpDeliveryService } from './smtp-delivery.service';
   ],
   providers: [
     InspectionReportsService,
+    InspectionReportWorkflowService,
     InspectionReportWordService,
     InspectionActPdfService,
     InspectionDocumentDeliveryService,

From 96093d9ed40b8eab5c97bc5d70573fca3a2bb39a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:58:49 -0300
Subject: [PATCH 029/224] refactor(f4): deliver editable INF Word to inspector

---
 .../inspection-document-delivery.service.ts   | 253 ++++++------------
 1 file changed, 79 insertions(+), 174 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-document-delivery.service.ts b/api-v3/src/inspection-reports/inspection-document-delivery.service.ts
index d855648..7b92038 100644
--- a/api-v3/src/inspection-reports/inspection-document-delivery.service.ts
+++ b/api-v3/src/inspection-reports/inspection-document-delivery.service.ts
@@ -10,7 +10,7 @@ import { InspectionActPdfService } from './inspection-act-pdf.service';
 import { InspectionReportWordService } from './inspection-report-word.service';
 import { SmtpDeliveryService } from './smtp-delivery.service';
 
-export type DeliveryRecipientKind = 'COMPANY' | 'OFFICE' | 'DIRECTOR' | 'INSPECTOR';
+export type DeliveryRecipientKind = 'COMPANY' | 'OFFICE' | 'INSPECTOR';
 
 export interface DeliveryRow {
   id: string;
@@ -40,21 +40,14 @@ export class InspectionDocumentDeliveryService {
 
   async settings() {
     const [row] = await this.dataSource.query(`
-      SELECT
-        office_email AS "officeEmail",
-        director_email AS "directorEmail",
-        updated_at AS "updatedAt"
+      SELECT office_email AS "officeEmail",updated_at AS "updatedAt"
       FROM institutional_delivery_settings
       WHERE id=1
-    `) as Array<{
-      officeEmail: string | null;
-      directorEmail: string | null;
-      updatedAt: Date;
-    }>;
+    `) as Array<{ officeEmail: string | null; updatedAt: Date }>;
     return {
       ...row,
-      smtpConfigured: this.smtp.configured(),
-      mailFrom: this.config.get<string>('MAIL_FROM') ?? null,
+      smtpConfigured: await this.smtp.configured(),
+      mailFrom: await this.smtp.fromAddress() ?? this.config.get<string>('MAIL_FROM') ?? null,
     };
   }
 
@@ -66,9 +59,9 @@ export class InspectionDocumentDeliveryService {
     const before = await this.settings();
     await this.dataSource.query(`
       UPDATE institutional_delivery_settings
-      SET office_email=$1,director_email=$2,updated_by=$3,updated_at=CURRENT_TIMESTAMP
+      SET office_email=$1,updated_by=$2,updated_at=CURRENT_TIMESTAMP
       WHERE id=1
-    `, [dto.officeEmail ?? null, dto.directorEmail ?? null, principal.userId]);
+    `, [dto.officeEmail ?? null, principal.userId]);
     const after = await this.settings();
     await this.audit.record({
       ...administrationAuditContext(principal, request),
@@ -84,33 +77,23 @@ export class InspectionDocumentDeliveryService {
   async list() {
     const data = await this.dataSource.query(`
       SELECT
-        d.id,
-        d.act_id AS "actId",
-        d.report_id AS "reportId",
-        d.document_kind AS "documentKind",
-        d.recipient_kind AS "recipientKind",
-        d.recipient_asset_id AS "recipientAssetId",
-        d.recipient_user_id AS "recipientUserId",
-        d.recipient_email AS "recipientEmail",
-        d.status,
-        d.attempts,
-        d.last_attempt_at AS "lastAttemptAt",
-        d.sent_at AS "sentAt",
-        d.provider_message_id AS "providerMessageId",
-        d.last_error AS "lastError",
-        d.created_at AS "createdAt",
-        a.code AS "actCode",
-        r.code AS "reportCode",
+        d.id,d.act_id AS "actId",d.report_id AS "reportId",
+        d.document_kind AS "documentKind",d.recipient_kind AS "recipientKind",
+        d.recipient_asset_id AS "recipientAssetId",d.recipient_user_id AS "recipientUserId",
+        d.recipient_email AS "recipientEmail",d.status,d.attempts,
+        d.last_attempt_at AS "lastAttemptAt",d.sent_at AS "sentAt",
+        d.provider_message_id AS "providerMessageId",d.last_error AS "lastError",
+        d.created_at AS "createdAt",a.code AS "actCode",r.code AS "reportCode",
         recipient.name AS "recipientAssetName",
-        CASE
-          WHEN recipient_user.id IS NULL THEN NULL
-          ELSE btrim(concat_ws(' ', recipient_user.first_name, recipient_user.last_name))
+        CASE WHEN recipient_user.id IS NULL THEN NULL
+          ELSE btrim(concat_ws(' ',recipient_user.first_name,recipient_user.last_name))
         END AS "recipientUserName"
       FROM inspection_document_deliveries d
       JOIN inspection_acts a ON a.id=d.act_id
       LEFT JOIN inspection_reports r ON r.id=d.report_id
       LEFT JOIN assets recipient ON recipient.id=d.recipient_asset_id
       LEFT JOIN users recipient_user ON recipient_user.id=d.recipient_user_id
+      WHERE d.recipient_kind<>'DIRECTOR'
       ORDER BY d.created_at DESC
       LIMIT 200
     `);
@@ -154,11 +137,9 @@ export class InspectionDocumentDeliveryService {
 
   async retryPending(principal: AuthPrincipal, request: RequestWithContext) {
     const rows = await this.dataSource.query(`
-      SELECT id
-      FROM inspection_document_deliveries
-      WHERE status<>'SENT'
-      ORDER BY created_at ASC
-      LIMIT 100
+      SELECT id FROM inspection_document_deliveries
+      WHERE status<>'SENT' AND recipient_kind<>'DIRECTOR'
+      ORDER BY created_at ASC LIMIT 100
     `) as Array<{ id: string }>;
     for (const item of rows) await this.retry(item.id, principal, request).catch(() => undefined);
     return { processed: rows.length };
@@ -166,10 +147,9 @@ export class InspectionDocumentDeliveryService {
 
   private async ensureRows(actId: string, reportId: string | null) {
     const [settings] = await this.dataSource.query(`
-      SELECT office_email AS "officeEmail",director_email AS "directorEmail"
-      FROM institutional_delivery_settings
-      WHERE id=1
-    `) as Array<{ officeEmail: string | null; directorEmail: string | null }>;
+      SELECT office_email AS "officeEmail"
+      FROM institutional_delivery_settings WHERE id=1
+    `) as Array<{ officeEmail: string | null }>;
 
     const companies = await this.dataSource.query(`
       SELECT DISTINCT company.id,profile.notification_email AS email
@@ -185,9 +165,7 @@ export class InspectionDocumentDeliveryService {
     `, [actId]) as Array<{ id: string; email: string | null }>;
 
     const [inspector] = await this.dataSource.query(`
-      SELECT
-        inspector.id,
-        inspector.email
+      SELECT inspector.id,inspector.email
       FROM inspection_acts act
       JOIN inspection_visits visit ON visit.id=act.visit_id
       JOIN users inspector ON inspector.id=visit.lead_inspector_user_id
@@ -196,52 +174,32 @@ export class InspectionDocumentDeliveryService {
 
     for (const company of companies) {
       await this.upsertRow({
-        actId,
-        reportId,
-        documentKind: 'ACT_PDF',
-        recipientKind: 'COMPANY',
-        recipientAssetId: company.id,
-        recipientUserId: null,
-        recipientKey: company.id,
-        recipientEmail: company.email,
+        actId,reportId,documentKind:'ACT_PDF',recipientKind:'COMPANY',
+        recipientAssetId:company.id,recipientUserId:null,recipientKey:company.id,
+        recipientEmail:company.email,
       });
     }
 
     await this.upsertRow({
-      actId,
-      reportId,
-      documentKind: 'ACT_PDF',
-      recipientKind: 'OFFICE',
-      recipientAssetId: null,
-      recipientUserId: null,
-      recipientKey: '00000000-0000-0000-0000-000000000000',
-      recipientEmail: settings?.officeEmail ?? null,
+      actId,reportId,documentKind:'ACT_PDF',recipientKind:'OFFICE',
+      recipientAssetId:null,recipientUserId:null,
+      recipientKey:'00000000-0000-0000-0000-000000000000',
+      recipientEmail:settings?.officeEmail ?? null,
     });
 
     if (inspector) {
       await this.upsertRow({
-        actId,
-        reportId,
-        documentKind: 'ACT_PDF',
-        recipientKind: 'INSPECTOR',
-        recipientAssetId: null,
-        recipientUserId: inspector.id,
-        recipientKey: inspector.id,
-        recipientEmail: inspector.email,
-      });
-    }
-
-    if (reportId) {
-      await this.upsertRow({
-        actId,
-        reportId,
-        documentKind: 'REPORT_WORD',
-        recipientKind: 'DIRECTOR',
-        recipientAssetId: null,
-        recipientUserId: null,
-        recipientKey: '00000000-0000-0000-0000-000000000000',
-        recipientEmail: settings?.directorEmail ?? null,
+        actId,reportId,documentKind:'ACT_PDF',recipientKind:'INSPECTOR',
+        recipientAssetId:null,recipientUserId:inspector.id,recipientKey:inspector.id,
+        recipientEmail:inspector.email,
       });
+      if (reportId) {
+        await this.upsertRow({
+          actId,reportId,documentKind:'REPORT_WORD',recipientKind:'INSPECTOR',
+          recipientAssetId:null,recipientUserId:inspector.id,recipientKey:inspector.id,
+          recipientEmail:inspector.email,
+        });
+      }
     }
   }
 
@@ -267,31 +225,21 @@ export class InspectionDocumentDeliveryService {
         recipient_user_id=COALESCE(EXCLUDED.recipient_user_id,inspection_document_deliveries.recipient_user_id),
         recipient_email=CASE
           WHEN inspection_document_deliveries.status='SENT' THEN inspection_document_deliveries.recipient_email
-          ELSE EXCLUDED.recipient_email
-        END,
+          ELSE EXCLUDED.recipient_email END,
         status=CASE
           WHEN inspection_document_deliveries.status='SENT' THEN 'SENT'
           WHEN EXCLUDED.recipient_email IS NULL THEN 'WAITING_RECIPIENT'
-          ELSE inspection_document_deliveries.status
-        END,
+          ELSE inspection_document_deliveries.status END,
         updated_at=CURRENT_TIMESTAMP
     `, [
-      input.actId,
-      input.reportId,
-      input.documentKind,
-      input.recipientKind,
-      input.recipientAssetId,
-      input.recipientUserId,
-      input.recipientKey,
-      input.recipientEmail,
-      initialStatus,
+      input.actId,input.reportId,input.documentKind,input.recipientKind,
+      input.recipientAssetId,input.recipientUserId,input.recipientKey,input.recipientEmail,initialStatus,
     ]);
   }
 
   private async rowsForAct(actId: string): Promise<DeliveryRow[]> {
     return this.dataSource.query(`
-      SELECT
-        d.id,d.act_id AS "actId",d.report_id AS "reportId",
+      SELECT d.id,d.act_id AS "actId",d.report_id AS "reportId",
         d.document_kind AS "documentKind",d.recipient_kind AS "recipientKind",
         d.recipient_asset_id AS "recipientAssetId",d.recipient_user_id AS "recipientUserId",
         d.recipient_email AS "recipientEmail",d.status,d.attempts,
@@ -299,15 +247,14 @@ export class InspectionDocumentDeliveryService {
       FROM inspection_document_deliveries d
       JOIN inspection_acts a ON a.id=d.act_id
       LEFT JOIN inspection_reports r ON r.id=d.report_id
-      WHERE d.act_id=$1
+      WHERE d.act_id=$1 AND d.recipient_kind<>'DIRECTOR'
       ORDER BY d.created_at
     `, [actId]) as Promise<DeliveryRow[]>;
   }
 
   private async load(id: string): Promise<DeliveryRow> {
     const [row] = await this.dataSource.query(`
-      SELECT
-        d.id,d.act_id AS "actId",d.report_id AS "reportId",
+      SELECT d.id,d.act_id AS "actId",d.report_id AS "reportId",
         d.document_kind AS "documentKind",d.recipient_kind AS "recipientKind",
         d.recipient_asset_id AS "recipientAssetId",d.recipient_user_id AS "recipientUserId",
         d.recipient_email AS "recipientEmail",d.status,d.attempts,
@@ -315,12 +262,11 @@ export class InspectionDocumentDeliveryService {
       FROM inspection_document_deliveries d
       JOIN inspection_acts a ON a.id=d.act_id
       LEFT JOIN inspection_reports r ON r.id=d.report_id
-      WHERE d.id=$1
+      WHERE d.id=$1 AND d.recipient_kind<>'DIRECTOR'
     `, [id]) as DeliveryRow[];
     if (!row) {
       throw new NotFoundException({
-        code: 'DOCUMENT_DELIVERY_NOT_FOUND',
-        message: 'Entrega documental no encontrada',
+        code:'DOCUMENT_DELIVERY_NOT_FOUND',message:'Entrega documental no encontrada',
       });
     }
     return row;
@@ -330,47 +276,37 @@ export class InspectionDocumentDeliveryService {
     let email: string | null = null;
     if (row.recipientKind === 'COMPANY' && row.recipientAssetId) {
       const [company] = await this.dataSource.query(`
-        SELECT notification_email AS email
-        FROM organization_profiles
-        WHERE asset_id=$1
+        SELECT notification_email AS email FROM organization_profiles WHERE asset_id=$1
       `, [row.recipientAssetId]) as Array<{ email: string | null }>;
       email = company?.email ?? null;
     } else if (row.recipientKind === 'INSPECTOR' && row.recipientUserId) {
       const [inspector] = await this.dataSource.query(`
-        SELECT email
-        FROM users
-        WHERE id=$1 AND is_active=true
+        SELECT email FROM users WHERE id=$1 AND is_active=true
       `, [row.recipientUserId]) as Array<{ email: string | null }>;
       email = inspector?.email ?? null;
     } else {
       const [settings] = await this.dataSource.query(`
-        SELECT office_email AS "officeEmail",director_email AS "directorEmail"
-        FROM institutional_delivery_settings
-        WHERE id=1
-      `) as Array<{ officeEmail: string | null; directorEmail: string | null }>;
-      email = row.recipientKind === 'OFFICE'
-        ? settings?.officeEmail ?? null
-        : settings?.directorEmail ?? null;
+        SELECT office_email AS "officeEmail" FROM institutional_delivery_settings WHERE id=1
+      `) as Array<{ officeEmail: string | null }>;
+      email = settings?.officeEmail ?? null;
     }
-
     await this.dataSource.query(`
       UPDATE inspection_document_deliveries
       SET recipient_email=$2,
           status=CASE WHEN $2::text IS NULL THEN 'WAITING_RECIPIENT' ELSE 'PENDING' END,
-          last_error=NULL,
-          updated_at=CURRENT_TIMESTAMP
+          last_error=NULL,updated_at=CURRENT_TIMESTAMP
       WHERE id=$1 AND status<>'SENT'
-    `, [row.id, email]);
+    `, [row.id,email]);
   }
 
   private async attempt(row: DeliveryRow) {
     if (row.status === 'SENT') return;
     if (!row.recipientEmail) {
-      await this.setStatus(row.id, 'WAITING_RECIPIENT', 'Destinatario no configurado');
+      await this.setStatus(row.id,'WAITING_RECIPIENT','Destinatario no configurado');
       return;
     }
-    if (!this.smtp.configured()) {
-      await this.setStatus(row.id, 'WAITING_TRANSPORT', 'SMTP no configurado');
+    if (!await this.smtp.configured()) {
+      await this.setStatus(row.id,'WAITING_TRANSPORT','SMTP no configurado');
       return;
     }
 
@@ -379,28 +315,18 @@ export class InspectionDocumentDeliveryService {
       if (row.documentKind === 'ACT_PDF') {
         await this.pdf.ensure(row.actId);
         const file = await this.pdf.content(row.actId);
-        attachment = {
-          filename: file.originalName,
-          mimeType: file.mimeType,
-          content: file.buffer,
-        };
+        attachment = { filename:file.originalName,mimeType:file.mimeType,content:file.buffer };
       } else {
         if (!row.reportId) throw new Error('Informe no vinculado');
         await this.word.ensure(row.reportId);
         const file = await this.word.content(row.reportId);
         const { readFile } = await import('node:fs/promises');
         attachment = {
-          filename: file.originalName,
-          mimeType: file.mimeType,
-          content: await readFile(file.filePath),
+          filename:file.originalName,mimeType:file.mimeType,content:await readFile(file.filePath),
         };
       }
     } catch (error) {
-      await this.setStatus(
-        row.id,
-        'WAITING_ARTIFACT',
-        error instanceof Error ? error.message : 'Documento no disponible',
-      );
+      await this.setStatus(row.id,'WAITING_ARTIFACT',error instanceof Error ? error.message : 'Documento no disponible');
       return;
     }
 
@@ -409,62 +335,41 @@ export class InspectionDocumentDeliveryService {
       SET attempts=attempts+1,last_attempt_at=CURRENT_TIMESTAMP,status='PENDING',
           last_error=NULL,updated_at=CURRENT_TIMESTAMP
       WHERE id=$1
-    `, [row.id]);
+    `,[row.id]);
 
     try {
       const label = row.documentKind === 'ACT_PDF'
         ? `Acta ${row.actCode}`
         : `Informe ${row.reportCode ?? ''}`;
       const text = row.documentKind === 'REPORT_WORD'
-        ? `Se adjunta el informe Word automático ${row.reportCode ?? ''} para revisión del Director de Hidrocarburos.`
+        ? `Se adjunta el INF editable ${row.reportCode ?? ''} para su revisión y preparación antes de cargarlo en GEDO.`
         : row.recipientKind === 'INSPECTOR'
-          ? `Se adjunta copia del acta cerrada e inmutable ${row.actCode} correspondiente a tu inspección.`
-          : `Se adjunta el acta cerrada e inmutable ${row.actCode}.`;
+          ? `Se adjunta copia del acta sellada e inmutable ${row.actCode} correspondiente a tu inspección.`
+          : `Se adjunta el acta sellada e inmutable ${row.actCode}.`;
       const sent = await this.smtp.send({
-        to: row.recipientEmail,
-        subject: `DH Inspección · ${label}`,
-        text,
-        attachment,
+        to:row.recipientEmail,subject:`DH Inspección · ${label}`,text,attachment,
       });
       await this.dataSource.query(`
         UPDATE inspection_document_deliveries
         SET status='SENT',sent_at=CURRENT_TIMESTAMP,provider_message_id=$2,
-            last_error=NULL,updated_at=CURRENT_TIMESTAMP
-        WHERE id=$1
-      `, [row.id, sent.messageId]);
+            last_error=NULL,updated_at=CURRENT_TIMESTAMP WHERE id=$1
+      `,[row.id,sent.messageId]);
       await this.audit.record({
-        action: AuditAction.DOCUMENT_DELIVERY_SENT,
-        entityType: 'inspection_document_delivery',
-        entityId: row.id,
-        source: AuditSource.SYSTEM,
-        actorUserId: null,
-        actorUsername: null,
-        requestId: null,
-        ip: null,
-        userAgent: null,
-        beforeData: null,
-        afterData: {
-          recipientKind: row.recipientKind,
-          recipientUserId: row.recipientUserId,
-          documentKind: row.documentKind,
-          status: 'SENT',
-        },
-        metadata: { actId: row.actId, reportId: row.reportId },
+        action:AuditAction.DOCUMENT_DELIVERY_SENT,
+        entityType:'inspection_document_delivery',entityId:row.id,source:AuditSource.SYSTEM,
+        actorUserId:null,actorUsername:null,requestId:null,ip:null,userAgent:null,beforeData:null,
+        afterData:{recipientKind:row.recipientKind,recipientUserId:row.recipientUserId,documentKind:row.documentKind,status:'SENT'},
+        metadata:{actId:row.actId,reportId:row.reportId},
       });
     } catch (error) {
-      await this.setStatus(
-        row.id,
-        'FAILED',
-        error instanceof Error ? error.message : 'Error de entrega',
-      );
+      await this.setStatus(row.id,'FAILED',error instanceof Error ? error.message : 'Error de entrega');
     }
   }
 
-  private async setStatus(id: string, status: string, error: string) {
+  private async setStatus(id: string,status: string,error: string) {
     await this.dataSource.query(`
       UPDATE inspection_document_deliveries
-      SET status=$2,last_error=$3,updated_at=CURRENT_TIMESTAMP
-      WHERE id=$1
-    `, [id, status, error.slice(0, 500)]);
+      SET status=$2,last_error=$3,updated_at=CURRENT_TIMESTAMP WHERE id=$1
+    `,[id,status,error.slice(0,500)]);
   }
 }

From ce3d3cf8b7490792e978f02a6b2d5bcd803e3b63 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 20:59:33 -0300
Subject: [PATCH 030/224] feat(f4): load SMTP from encrypted superadmin
 settings

---
 .../smtp-delivery.service.ts                  | 178 +++++++++++++++++-
 1 file changed, 169 insertions(+), 9 deletions(-)

diff --git a/api-v3/src/inspection-reports/smtp-delivery.service.ts b/api-v3/src/inspection-reports/smtp-delivery.service.ts
index bce88d6..0e54de4 100644
--- a/api-v3/src/inspection-reports/smtp-delivery.service.ts
+++ b/api-v3/src/inspection-reports/smtp-delivery.service.ts
@@ -1,13 +1,27 @@
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from 'node:crypto';
 import { connect as connectNet, Socket } from 'node:net';
 import { connect as connectTls, TLSSocket } from 'node:tls';
-import { randomUUID } from 'node:crypto';
-import { ConfigService } from '@nestjs/config';
 import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DataSource } from 'typeorm';
+import { SmtpSecurityMode } from '../database/entities';
 
 interface MailAttachment { filename:string; mimeType:string; content:Buffer; }
 interface MailInput { to:string; subject:string; text:string; attachment:MailAttachment; }
 interface Reply { code:number; text:string; }
 
+export interface EffectiveSmtpSettings {
+  source: 'DATABASE' | 'ENVIRONMENT';
+  host: string;
+  port: number;
+  securityMode: SmtpSecurityMode;
+  username: string | null;
+  password: string;
+  fromName: string | null;
+  fromEmail: string;
+  replyTo: string | null;
+}
+
 class SmtpSession {
   private buffer=''; private waiters:Array<(reply:Reply)=>void>=[]; private replyLines:string[]=[];
   private readonly dataHandler=(chunk:Buffer|string)=>this.onData(typeof chunk==='string'?chunk:chunk.toString('utf8'));
@@ -20,18 +34,164 @@ class SmtpSession {
   async command(command:string, expected:number|number[]){ this.socket.write(`${command}\r\n`); const reply=await this.reply(); const allowed=Array.isArray(expected)?expected:[expected]; if(!allowed.includes(reply.code))throw new Error(`SMTP ${reply.code}: ${reply.text}`); return reply; }
   write(data:string){this.socket.write(data);}
   end(){this.socket.end();}
-  current(){return this.socket;}
 }
 
 function subject(value:string){return `=?UTF-8?B?${Buffer.from(value,'utf8').toString('base64')}?=`;}
 function envelope(value:string){const m=value.match(/<([^>]+)>/);return (m?.[1]??value).trim();}
-function mime(input:MailInput,from:string){ const boundary=`dh-${randomUUID()}`; const body=[`From: ${from}`,`To: ${input.to}`,`Subject: ${subject(input.subject)}`,'MIME-Version: 1.0',`Content-Type: multipart/mixed; boundary="${boundary}"`,'',`--${boundary}`,'Content-Type: text/plain; charset=utf-8','Content-Transfer-Encoding: base64','',Buffer.from(input.text,'utf8').toString('base64'),`--${boundary}`,`Content-Type: ${input.attachment.mimeType}; name="${input.attachment.filename.replaceAll('"','')}"`,'Content-Transfer-Encoding: base64',`Content-Disposition: attachment; filename="${input.attachment.filename.replaceAll('"','')}"`,'',input.attachment.content.toString('base64').replace(/(.{76})/g,'$1\r\n'),`--${boundary}--`,''].join('\r\n'); return body.replace(/^\./gm,'..'); }
+function mime(input:MailInput,from:string,replyTo:string|null){ const boundary=`dh-${randomUUID()}`; const body=[`From: ${from}`,`To: ${input.to}`,replyTo?`Reply-To: ${replyTo}`:null,`Subject: ${subject(input.subject)}`,'MIME-Version: 1.0',`Content-Type: multipart/mixed; boundary="${boundary}"`,'',`--${boundary}`,'Content-Type: text/plain; charset=utf-8','Content-Transfer-Encoding: base64','',Buffer.from(input.text,'utf8').toString('base64'),`--${boundary}`,`Content-Type: ${input.attachment.mimeType}; name="${input.attachment.filename.replaceAll('"','')}"`,'Content-Transfer-Encoding: base64',`Content-Disposition: attachment; filename="${input.attachment.filename.replaceAll('"','')}"`,'',input.attachment.content.toString('base64').replace(/(.{76})/g,'$1\r\n'),`--${boundary}--`,''].filter((line):line is string=>line!==null).join('\r\n'); return body.replace(/^\./gm,'..'); }
 
 @Injectable()
 export class SmtpDeliveryService {
-  constructor(private readonly config:ConfigService){}
-  configured(){return Boolean(this.config.get<string>('SMTP_HOST')&&this.config.get<string>('MAIL_FROM'));}
-  async send(input:MailInput):Promise<{messageId:string}>{ const host=this.config.get<string>('SMTP_HOST'); const from=this.config.get<string>('MAIL_FROM'); if(!host||!from)throw new Error('SMTP no configurado'); const port=Number(this.config.get<string>('SMTP_PORT')??587); const secure=String(this.config.get<string>('SMTP_SECURE')??'false').toLowerCase()==='true'; const user=this.config.get<string>('SMTP_USER')??''; const pass=this.config.get<string>('SMTP_PASS')??''; const base=await new Promise<Socket|TLSSocket>((resolve,reject)=>{ if(secure){ const tls=connectTls({host,port,servername:host,rejectUnauthorized:true},()=>resolve(tls)); tls.once('error',reject); } else { const raw=connectNet({host,port},()=>resolve(raw)); raw.once('error',reject); } }); const session=new SmtpSession(base); const welcome=await session.reply(); if(welcome.code!==220)throw new Error(`SMTP ${welcome.code}: ${welcome.text}`); let ehlo=await session.command(`EHLO dh-inspeccion`,250); if(!secure){ if(!/STARTTLS/i.test(ehlo.text))throw new Error('El servidor SMTP no ofrece STARTTLS'); await session.command('STARTTLS',220); const rawForTls=session.detachForUpgrade() as Socket; const upgraded=await new Promise<TLSSocket>((resolve,reject)=>{ const tls=connectTls({socket:rawForTls,servername:host,rejectUnauthorized:true},()=>resolve(tls)); tls.once('error',reject); }); session.replaceSocket(upgraded); ehlo=await session.command('EHLO dh-inspeccion',250); }
-    if(user){ if(/AUTH[^\n]*PLAIN/i.test(ehlo.text)){ const token=Buffer.from(`\u0000${user}\u0000${pass}`,'utf8').toString('base64'); await session.command(`AUTH PLAIN ${token}`,235); } else { await session.command('AUTH LOGIN',334); await session.command(Buffer.from(user).toString('base64'),334); await session.command(Buffer.from(pass).toString('base64'),235); } }
-    await session.command(`MAIL FROM:<${envelope(from)}>`,250); await session.command(`RCPT TO:<${input.to}>`,[250,251]); await session.command('DATA',354); session.write(`${mime(input,from)}\r\n.\r\n`); const sent=await session.reply(); if(sent.code!==250)throw new Error(`SMTP ${sent.code}: ${sent.text}`); await session.command('QUIT',221).catch(()=>undefined); session.end(); const match=sent.text.match(/(?:queued as|id=|message-id[=:]?)[\s<]*([^\s>]+)/i); return {messageId:match?.[1]??randomUUID()}; }
+  constructor(
+    private readonly dataSource:DataSource,
+    private readonly config:ConfigService,
+  ){}
+
+  async configured():Promise<boolean>{return Boolean(await this.resolveSettings());}
+
+  async fromAddress():Promise<string|null>{
+    const settings=await this.resolveSettings();
+    if(!settings)return null;
+    return settings.fromName?`${settings.fromName} <${settings.fromEmail}>`:settings.fromEmail;
+  }
+
+  async publicSettings(){
+    const [row]=await this.dataSource.query(`
+      SELECT id,host,port,security_mode AS "securityMode",username,
+        (password_enc IS NOT NULL) AS "hasPassword",from_name AS "fromName",
+        from_email AS "fromEmail",reply_to AS "replyTo",enabled,
+        updated_at AS "updatedAt"
+      FROM system_smtp_settings ORDER BY created_at LIMIT 1
+    `) as Array<Record<string,unknown>>;
+    if(row)return {...row,source:'DATABASE'};
+    const fallback=await this.resolveEnvironment();
+    return fallback?{
+      source:'ENVIRONMENT',host:fallback.host,port:fallback.port,
+      securityMode:fallback.securityMode,username:fallback.username,
+      hasPassword:Boolean(fallback.password),fromName:fallback.fromName,
+      fromEmail:fallback.fromEmail,replyTo:fallback.replyTo,enabled:true,
+    }:{source:'NONE',enabled:false};
+  }
+
+  async saveSettings(input:{
+    host:string;port:number;securityMode:SmtpSecurityMode;username?:string|null;
+    password?:string|null;fromName:string;fromEmail:string;replyTo?:string|null;enabled:boolean;
+  },userId:string){
+    const [existing]=await this.dataSource.query(`SELECT id,password_enc AS "passwordEnc" FROM system_smtp_settings ORDER BY created_at LIMIT 1`) as Array<{id:string;passwordEnc:string|null}>;
+    const passwordEnc=input.password===undefined
+      ? existing?.passwordEnc??null
+      : input.password?this.encryptSecret(input.password):null;
+    if(existing){
+      await this.dataSource.query(`
+        UPDATE system_smtp_settings SET host=$2,port=$3,security_mode=$4,username=$5,
+          password_enc=$6,from_name=$7,from_email=$8,reply_to=$9,enabled=$10,
+          updated_by=$11,updated_at=CURRENT_TIMESTAMP WHERE id=$1
+      `,[existing.id,input.host,input.port,input.securityMode,input.username??null,passwordEnc,input.fromName,input.fromEmail,input.replyTo??null,input.enabled,userId]);
+    }else{
+      await this.dataSource.query(`
+        INSERT INTO system_smtp_settings(host,port,security_mode,username,password_enc,from_name,from_email,reply_to,enabled,updated_by)
+        VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
+      `,[input.host,input.port,input.securityMode,input.username??null,passwordEnc,input.fromName,input.fromEmail,input.replyTo??null,input.enabled,userId]);
+    }
+    return this.publicSettings();
+  }
+
+  async send(input:MailInput):Promise<{messageId:string}>{
+    const settings=await this.resolveSettings();
+    if(!settings)throw new Error('SMTP no configurado');
+    const {host,port,securityMode,userName,password}= {
+      host:settings.host,port:settings.port,securityMode:settings.securityMode,
+      userName:settings.username??'',password:settings.password,
+    };
+    const implicitTls=securityMode===SmtpSecurityMode.TLS;
+    const base=await new Promise<Socket|TLSSocket>((resolve,reject)=>{
+      if(implicitTls){ const tls=connectTls({host,port,servername:host,rejectUnauthorized:true},()=>resolve(tls)); tls.once('error',reject); }
+      else { const raw=connectNet({host,port},()=>resolve(raw)); raw.once('error',reject); }
+    });
+    const session=new SmtpSession(base);
+    const welcome=await session.reply();
+    if(welcome.code!==220)throw new Error(`SMTP ${welcome.code}: ${welcome.text}`);
+    let ehlo=await session.command('EHLO dh-inspeccion',250);
+    if(securityMode===SmtpSecurityMode.STARTTLS){
+      if(!/STARTTLS/i.test(ehlo.text))throw new Error('El servidor SMTP no ofrece STARTTLS');
+      await session.command('STARTTLS',220);
+      const rawForTls=session.detachForUpgrade() as Socket;
+      const upgraded=await new Promise<TLSSocket>((resolve,reject)=>{ const tls=connectTls({socket:rawForTls,servername:host,rejectUnauthorized:true},()=>resolve(tls)); tls.once('error',reject); });
+      session.replaceSocket(upgraded);
+      ehlo=await session.command('EHLO dh-inspeccion',250);
+    }
+    if(userName){
+      if(/AUTH[^\n]*PLAIN/i.test(ehlo.text)){ const token=Buffer.from(`\u0000${userName}\u0000${password}`,'utf8').toString('base64'); await session.command(`AUTH PLAIN ${token}`,235); }
+      else { await session.command('AUTH LOGIN',334); await session.command(Buffer.from(userName).toString('base64'),334); await session.command(Buffer.from(password).toString('base64'),235); }
+    }
+    const from=settings.fromName?`${settings.fromName} <${settings.fromEmail}>`:settings.fromEmail;
+    await session.command(`MAIL FROM:<${envelope(from)}>`,250);
+    await session.command(`RCPT TO:<${input.to}>`,[250,251]);
+    await session.command('DATA',354);
+    session.write(`${mime(input,from,settings.replyTo)}\r\n.\r\n`);
+    const sent=await session.reply();
+    if(sent.code!==250)throw new Error(`SMTP ${sent.code}: ${sent.text}`);
+    await session.command('QUIT',221).catch(()=>undefined);
+    session.end();
+    const match=sent.text.match(/(?:queued as|id=|message-id[=:]?)[\s<]*([^\s>]+)/i);
+    return {messageId:match?.[1]??randomUUID()};
+  }
+
+  private async resolveSettings():Promise<EffectiveSmtpSettings|null>{
+    const [row]=await this.dataSource.query(`
+      SELECT host,port,security_mode AS "securityMode",username,password_enc AS "passwordEnc",
+        from_name AS "fromName",from_email AS "fromEmail",reply_to AS "replyTo",enabled
+      FROM system_smtp_settings ORDER BY created_at LIMIT 1
+    `) as Array<{
+      host:string;port:number;securityMode:SmtpSecurityMode;username:string|null;passwordEnc:string|null;
+      fromName:string;fromEmail:string;replyTo:string|null;enabled:boolean;
+    }>;
+    if(row){
+      if(!row.enabled)return null;
+      return {
+        source:'DATABASE',host:row.host,port:Number(row.port),securityMode:row.securityMode,
+        username:row.username,password:row.passwordEnc?this.decryptSecret(row.passwordEnc):'',
+        fromName:row.fromName,fromEmail:row.fromEmail,replyTo:row.replyTo,
+      };
+    }
+    return this.resolveEnvironment();
+  }
+
+  private async resolveEnvironment():Promise<EffectiveSmtpSettings|null>{
+    const host=this.config.get<string>('SMTP_HOST');
+    const rawFrom=this.config.get<string>('MAIL_FROM');
+    if(!host||!rawFrom)return null;
+    const fromEmail=envelope(rawFrom);
+    const fromName=rawFrom.includes('<')?rawFrom.slice(0,rawFrom.indexOf('<')).trim().replace(/^"|"$/g,'')||null:null;
+    const secure=String(this.config.get<string>('SMTP_SECURE')??'false').toLowerCase()==='true';
+    return {
+      source:'ENVIRONMENT',host,port:Number(this.config.get<string>('SMTP_PORT')??(secure?465:587)),
+      securityMode:secure?SmtpSecurityMode.TLS:SmtpSecurityMode.STARTTLS,
+      username:this.config.get<string>('SMTP_USER')??null,password:this.config.get<string>('SMTP_PASS')??'',
+      fromName,fromEmail,replyTo:null,
+    };
+  }
+
+  private encryptionKey():Buffer{
+    const raw=this.config.get<string>('SMTP_SETTINGS_MASTER_KEY');
+    if(!raw)throw new Error('SMTP_SETTINGS_MASTER_KEY no configurada');
+    const key=/^[0-9a-fA-F]{64}$/.test(raw)?Buffer.from(raw,'hex'):Buffer.from(raw,'base64');
+    if(key.length!==32)throw new Error('SMTP_SETTINGS_MASTER_KEY debe contener exactamente 32 bytes');
+    return key;
+  }
+
+  private encryptSecret(value:string):string{
+    const iv=randomBytes(12); const cipher=createCipheriv('aes-256-gcm',this.encryptionKey(),iv);
+    const encrypted=Buffer.concat([cipher.update(value,'utf8'),cipher.final()]);
+    const tag=cipher.getAuthTag();
+    return `v1:${iv.toString('base64')}:${tag.toString('base64')}:${encrypted.toString('base64')}`;
+  }
+
+  private decryptSecret(value:string):string{
+    const [version,ivB64,tagB64,cipherB64]=value.split(':');
+    if(version!=='v1'||!ivB64||!tagB64||!cipherB64)throw new Error('Credencial SMTP cifrada inválida');
+    const decipher=createDecipheriv('aes-256-gcm',this.encryptionKey(),Buffer.from(ivB64,'base64'));
+    decipher.setAuthTag(Buffer.from(tagB64,'base64'));
+    return Buffer.concat([decipher.update(Buffer.from(cipherB64,'base64')),decipher.final()]).toString('utf8');
+  }
 }

From a7f53f32f01e25b6c89672061df1a2f3315f6006 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:01:02 -0300
Subject: [PATCH 031/224] refactor(f4): remove obsolete Director delivery
 setting

---
 .../dto/update-document-delivery-settings.dto.ts   | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/api-v3/src/inspection-reports/dto/update-document-delivery-settings.dto.ts b/api-v3/src/inspection-reports/dto/update-document-delivery-settings.dto.ts
index 3ed84a0..b5be54d 100644
--- a/api-v3/src/inspection-reports/dto/update-document-delivery-settings.dto.ts
+++ b/api-v3/src/inspection-reports/dto/update-document-delivery-settings.dto.ts
@@ -1,2 +1,12 @@
-import { Transform } from 'class-transformer'; import { IsEmail,IsOptional,MaxLength } from 'class-validator';
-export class UpdateDocumentDeliverySettingsDto { @IsOptional() @Transform(({value})=>typeof value==='string'&&value.trim()?value.trim().toLowerCase():null) @IsEmail() @MaxLength(320) officeEmail?:string|null; @IsOptional() @Transform(({value})=>typeof value==='string'&&value.trim()?value.trim().toLowerCase():null) @IsEmail() @MaxLength(320) directorEmail?:string|null; }
+import { Transform } from 'class-transformer';
+import { IsEmail, IsOptional, MaxLength } from 'class-validator';
+
+export class UpdateDocumentDeliverySettingsDto {
+  @IsOptional()
+  @Transform(({ value }) =>
+    typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : null,
+  )
+  @IsEmail()
+  @MaxLength(320)
+  officeEmail?: string | null;
+}

From 489fb309b3cb6dadc9ceaf435ad0c74ade3b18b9 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:01:14 -0300
Subject: [PATCH 032/224] feat(f4): add superadmin SMTP settings DTO

---
 .../dto/update-smtp-settings.dto.ts           | 71 +++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/dto/update-smtp-settings.dto.ts

diff --git a/api-v3/src/inspection-reports/dto/update-smtp-settings.dto.ts b/api-v3/src/inspection-reports/dto/update-smtp-settings.dto.ts
new file mode 100644
index 0000000..8f70893
--- /dev/null
+++ b/api-v3/src/inspection-reports/dto/update-smtp-settings.dto.ts
@@ -0,0 +1,71 @@
+import { Transform, Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsEmail,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  Max,
+  MaxLength,
+  Min,
+  MinLength,
+} from 'class-validator';
+import { SmtpSecurityMode } from '../../database/entities';
+
+export class UpdateSmtpSettingsDto {
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  host!: string;
+
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(65535)
+  port!: number;
+
+  @IsEnum(SmtpSecurityMode)
+  securityMode!: SmtpSecurityMode;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() || null : value)
+  @IsString()
+  @MaxLength(255)
+  username?: string | null;
+
+  /** Omitir para conservar la clave actual; enviar null/cadena vacía para quitarla. */
+  @IsOptional()
+  @IsString()
+  @MaxLength(1000)
+  password?: string | null;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(1)
+  @MaxLength(200)
+  fromName!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim().toLowerCase() : value)
+  @IsEmail()
+  @MaxLength(320)
+  fromEmail!: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : null)
+  @IsEmail()
+  @MaxLength(320)
+  replyTo?: string | null;
+
+  @Transform(({ value }) => value === true || value === 'true')
+  @IsBoolean()
+  enabled!: boolean;
+}
+
+export class TestSmtpSettingsDto {
+  @Transform(({ value }) => typeof value === 'string' ? value.trim().toLowerCase() : value)
+  @IsEmail()
+  @MaxLength(320)
+  email!: string;
+}

From 2d97398c018af9c153fbe24672e2d03ff6365094 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:01:44 -0300
Subject: [PATCH 033/224] feat(f4): add Superadmin SMTP management endpoints

---
 .../document-delivery.controller.ts           | 113 ++++++++++++++++--
 1 file changed, 106 insertions(+), 7 deletions(-)

diff --git a/api-v3/src/inspection-reports/document-delivery.controller.ts b/api-v3/src/inspection-reports/document-delivery.controller.ts
index 54704b4..5fe49ca 100644
--- a/api-v3/src/inspection-reports/document-delivery.controller.ts
+++ b/api-v3/src/inspection-reports/document-delivery.controller.ts
@@ -1,17 +1,116 @@
-import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Req } from '@nestjs/common';
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Put, Req } from '@nestjs/common';
 import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
 import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { administrationAuditContext } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import { AuditAction } from '../database/entities';
 import { InspectionDocumentDeliveryService } from './inspection-document-delivery.service';
 import type { DeliveryRow } from './inspection-document-delivery.service';
+import { SmtpDeliveryService } from './smtp-delivery.service';
 import { UpdateDocumentDeliverySettingsDto } from './dto/update-document-delivery-settings.dto';
+import { TestSmtpSettingsDto, UpdateSmtpSettingsDto } from './dto/update-smtp-settings.dto';
 
 @Controller('document-delivery')
 export class DocumentDeliveryController {
-  constructor(private readonly delivery:InspectionDocumentDeliveryService){}
-  @Get('settings') @RequirePermissions('document_delivery.read') settings(){return this.delivery.settings();}
-  @Patch('settings') @RequirePermissions('document_delivery.manage') update(@Body() dto:UpdateDocumentDeliverySettingsDto,@CurrentAuth() principal:AuthPrincipal,@Req() request:RequestWithContext){return this.delivery.updateSettings(dto,principal,request);}
-  @Get('outbox') @RequirePermissions('document_delivery.read') outbox(){return this.delivery.list();}
-  @Post('outbox/:id/retry') @RequirePermissions('document_delivery.manage') retry(@Param('id',new ParseUUIDPipe({version:'4'})) id:string,@CurrentAuth() principal:AuthPrincipal,@Req() request:RequestWithContext):Promise<DeliveryRow>{return this.delivery.retry(id,principal,request);}
-  @Post('outbox/retry-pending') @RequirePermissions('document_delivery.manage') retryPending(@CurrentAuth() principal:AuthPrincipal,@Req() request:RequestWithContext){return this.delivery.retryPending(principal,request);}
+  constructor(
+    private readonly delivery: InspectionDocumentDeliveryService,
+    private readonly smtp: SmtpDeliveryService,
+    private readonly audit: AuditService,
+  ) {}
+
+  @Get('settings')
+  @RequirePermissions('document_delivery.read')
+  settings() {
+    return this.delivery.settings();
+  }
+
+  @Patch('settings')
+  @RequirePermissions('document_delivery.manage')
+  update(
+    @Body() dto: UpdateDocumentDeliverySettingsDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.delivery.updateSettings(dto, principal, request);
+  }
+
+  @Get('smtp')
+  @RequirePermissions('document_delivery.manage')
+  smtpSettings() {
+    return this.smtp.publicSettings();
+  }
+
+  @Put('smtp')
+  @RequirePermissions('document_delivery.manage')
+  async updateSmtp(
+    @Body() dto: UpdateSmtpSettingsDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    const before = await this.smtp.publicSettings();
+    const after = await this.smtp.saveSettings(dto, principal.userId);
+    await this.audit.record({
+      ...administrationAuditContext(principal, request),
+      action: AuditAction.SMTP_SETTINGS_UPDATED,
+      entityType: 'system_smtp_settings',
+      entityId: 'singleton',
+      beforeData: before as Record<string, unknown>,
+      afterData: after as Record<string, unknown>,
+      metadata: { passwordNeverReturned: true },
+    });
+    return after;
+  }
+
+  @Post('smtp/test')
+  @RequirePermissions('document_delivery.manage')
+  async testSmtp(
+    @Body() dto: TestSmtpSettingsDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    const sent = await this.smtp.send({
+      to: dto.email,
+      subject: 'DH Inspección · Prueba SMTP',
+      text: 'Este correo confirma que la configuración SMTP de DH Inspección funciona correctamente.',
+      attachment: {
+        filename: 'dh-inspeccion-smtp-test.txt',
+        mimeType: 'text/plain',
+        content: Buffer.from('DH Inspección · Prueba SMTP OK\n', 'utf8'),
+      },
+    });
+    await this.audit.record({
+      ...administrationAuditContext(principal, request),
+      action: AuditAction.SMTP_TEST_SENT,
+      entityType: 'system_smtp_settings',
+      entityId: 'singleton',
+      afterData: { recipient: dto.email, messageId: sent.messageId },
+    });
+    return { ok: true, recipient: dto.email, messageId: sent.messageId };
+  }
+
+  @Get('outbox')
+  @RequirePermissions('document_delivery.read')
+  outbox() {
+    return this.delivery.list();
+  }
+
+  @Post('outbox/:id/retry')
+  @RequirePermissions('document_delivery.manage')
+  retry(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ): Promise<DeliveryRow> {
+    return this.delivery.retry(id, principal, request);
+  }
+
+  @Post('outbox/retry-pending')
+  @RequirePermissions('document_delivery.manage')
+  retryPending(
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.delivery.retryPending(principal, request);
+  }
 }

From d071e6be742e158f873a9906d5d050ca75cf2273 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:02:27 -0300
Subject: [PATCH 034/224] feat(f4): add JEFE deadline administration DTOs

---
 .../dto/update-deadline-policy.dto.ts         | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/dto/update-deadline-policy.dto.ts

diff --git a/api-v3/src/inspection-reports/dto/update-deadline-policy.dto.ts b/api-v3/src/inspection-reports/dto/update-deadline-policy.dto.ts
new file mode 100644
index 0000000..4407473
--- /dev/null
+++ b/api-v3/src/inspection-reports/dto/update-deadline-policy.dto.ts
@@ -0,0 +1,48 @@
+import { Transform, Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsInt,
+  IsString,
+  Max,
+  MaxLength,
+  Min,
+  MinLength,
+} from 'class-validator';
+import { InspectionDeadlineDayType } from '../../database/entities';
+
+export class UpdateDeadlinePolicyDto {
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(365)
+  urgentDays!: number;
+
+  @IsEnum(InspectionDeadlineDayType)
+  urgentDayType!: InspectionDeadlineDayType;
+
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(365)
+  nonUrgentDays!: number;
+
+  @IsEnum(InspectionDeadlineDayType)
+  nonUrgentDayType!: InspectionDeadlineDayType;
+}
+
+export class UpsertBusinessCalendarDayDto {
+  @IsDateString()
+  date!: string;
+
+  @Transform(({ value }) => value === true || value === 'true')
+  @IsBoolean()
+  isBusinessDay!: boolean;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(1)
+  @MaxLength(200)
+  label!: string;
+}

From 9a79b7eb866806b7e9a982d084e584605721336e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:02:44 -0300
Subject: [PATCH 035/224] feat(f4): implement JEFE deadline policy and calendar
 administration

---
 .../inspection-deadline-admin.service.ts      | 160 ++++++++++++++++++
 1 file changed, 160 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/inspection-deadline-admin.service.ts

diff --git a/api-v3/src/inspection-reports/inspection-deadline-admin.service.ts b/api-v3/src/inspection-reports/inspection-deadline-admin.service.ts
new file mode 100644
index 0000000..d4e62aa
--- /dev/null
+++ b/api-v3/src/inspection-reports/inspection-deadline-admin.service.ts
@@ -0,0 +1,160 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { administrationAuditContext } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { AuditAction } from '../database/entities';
+import type { UpdateDeadlinePolicyDto, UpsertBusinessCalendarDayDto } from './dto/update-deadline-policy.dto';
+
+@Injectable()
+export class InspectionDeadlineAdminService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly audit: AuditService,
+  ) {}
+
+  async policy() {
+    const [row] = await this.dataSource.query(`
+      SELECT id,
+        urgent_days AS "urgentDays",
+        urgent_day_type AS "urgentDayType",
+        non_urgent_days AS "nonUrgentDays",
+        non_urgent_day_type AS "nonUrgentDayType",
+        updated_by AS "updatedBy",
+        updated_at AS "updatedAt"
+      FROM inspection_deadline_policies
+      ORDER BY created_at
+      LIMIT 1
+    `);
+    return row ?? {
+      urgentDays: 5,
+      urgentDayType: 'BUSINESS',
+      nonUrgentDays: 10,
+      nonUrgentDayType: 'BUSINESS',
+    };
+  }
+
+  async updatePolicy(
+    dto: UpdateDeadlinePolicyDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    const before = await this.policy();
+    const [existing] = await this.dataSource.query(`
+      SELECT id FROM inspection_deadline_policies ORDER BY created_at LIMIT 1
+    `) as Array<{ id: string }>;
+    if (existing) {
+      await this.dataSource.query(`
+        UPDATE inspection_deadline_policies
+        SET urgent_days=$2,
+            urgent_day_type=$3,
+            non_urgent_days=$4,
+            non_urgent_day_type=$5,
+            updated_by=$6,
+            updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1
+      `, [
+        existing.id,
+        dto.urgentDays,
+        dto.urgentDayType,
+        dto.nonUrgentDays,
+        dto.nonUrgentDayType,
+        principal.userId,
+      ]);
+    } else {
+      await this.dataSource.query(`
+        INSERT INTO inspection_deadline_policies(
+          urgent_days,urgent_day_type,non_urgent_days,non_urgent_day_type,updated_by
+        ) VALUES($1,$2,$3,$4,$5)
+      `, [
+        dto.urgentDays,
+        dto.urgentDayType,
+        dto.nonUrgentDays,
+        dto.nonUrgentDayType,
+        principal.userId,
+      ]);
+    }
+    const after = await this.policy();
+    await this.audit.record({
+      ...administrationAuditContext(principal, request),
+      action: AuditAction.INSPECTION_DEADLINE_POLICY_UPDATED,
+      entityType: 'inspection_deadline_policy',
+      entityId: String((after as { id?: string }).id ?? 'singleton'),
+      beforeData: before as Record<string, unknown>,
+      afterData: after as Record<string, unknown>,
+      metadata: {
+        appliesOnlyToFutureLockedActs: true,
+        historicalActsKeepSnapshot: true,
+      },
+    });
+    return after;
+  }
+
+  async calendar() {
+    const data = await this.dataSource.query(`
+      SELECT id,date,is_business_day AS "isBusinessDay",label,
+        updated_by AS "updatedBy",created_at AS "createdAt",updated_at AS "updatedAt"
+      FROM inspection_business_calendar_days
+      ORDER BY date
+    `);
+    return { data };
+  }
+
+  async upsertCalendarDay(
+    dto: UpsertBusinessCalendarDayDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    const [before] = await this.dataSource.query(`
+      SELECT id,date,is_business_day AS "isBusinessDay",label
+      FROM inspection_business_calendar_days WHERE date=$1::date
+    `, [dto.date]);
+    await this.dataSource.query(`
+      INSERT INTO inspection_business_calendar_days(date,is_business_day,label,updated_by)
+      VALUES($1::date,$2,$3,$4)
+      ON CONFLICT(date) DO UPDATE SET
+        is_business_day=EXCLUDED.is_business_day,
+        label=EXCLUDED.label,
+        updated_by=EXCLUDED.updated_by,
+        updated_at=CURRENT_TIMESTAMP
+    `, [dto.date, dto.isBusinessDay, dto.label, principal.userId]);
+    const [after] = await this.dataSource.query(`
+      SELECT id,date,is_business_day AS "isBusinessDay",label,
+        updated_by AS "updatedBy",updated_at AS "updatedAt"
+      FROM inspection_business_calendar_days WHERE date=$1::date
+    `, [dto.date]);
+    await this.audit.record({
+      ...administrationAuditContext(principal, request),
+      action: AuditAction.INSPECTION_BUSINESS_CALENDAR_UPDATED,
+      entityType: 'inspection_business_calendar_day',
+      entityId: String(after.id),
+      beforeData: before ?? null,
+      afterData: after,
+    });
+    return after;
+  }
+
+  async removeCalendarDay(
+    date: string,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    const [before] = await this.dataSource.query(`
+      SELECT id,date,is_business_day AS "isBusinessDay",label
+      FROM inspection_business_calendar_days WHERE date=$1::date
+    `, [date]);
+    if (before) {
+      await this.dataSource.query(`DELETE FROM inspection_business_calendar_days WHERE id=$1`, [before.id]);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_BUSINESS_CALENDAR_UPDATED,
+        entityType: 'inspection_business_calendar_day',
+        entityId: String(before.id),
+        beforeData: before,
+        afterData: null,
+        metadata: { removed: true },
+      });
+    }
+    return { removed: Boolean(before), date };
+  }
+}

From 5e6631554a34b86acfbce3a1feb40887c861807e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:02:54 -0300
Subject: [PATCH 036/224] feat(f4): expose JEFE deadline policy endpoints

---
 .../inspection-deadline-admin.controller.ts   | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 api-v3/src/inspection-reports/inspection-deadline-admin.controller.ts

diff --git a/api-v3/src/inspection-reports/inspection-deadline-admin.controller.ts b/api-v3/src/inspection-reports/inspection-deadline-admin.controller.ts
new file mode 100644
index 0000000..4869ec6
--- /dev/null
+++ b/api-v3/src/inspection-reports/inspection-deadline-admin.controller.ts
@@ -0,0 +1,53 @@
+import { Body, Controller, Delete, Get, Param, Put, Req } from '@nestjs/common';
+import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
+import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { UpdateDeadlinePolicyDto, UpsertBusinessCalendarDayDto } from './dto/update-deadline-policy.dto';
+import { InspectionDeadlineAdminService } from './inspection-deadline-admin.service';
+
+@Controller('inspection-deadlines')
+export class InspectionDeadlineAdminController {
+  constructor(private readonly deadlines: InspectionDeadlineAdminService) {}
+
+  @Get('policy')
+  @RequirePermissions('inspections.read')
+  policy() {
+    return this.deadlines.policy();
+  }
+
+  @Put('policy')
+  @RequirePermissions('inspections.manage')
+  updatePolicy(
+    @Body() dto: UpdateDeadlinePolicyDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.deadlines.updatePolicy(dto, principal, request);
+  }
+
+  @Get('calendar')
+  @RequirePermissions('inspections.read')
+  calendar() {
+    return this.deadlines.calendar();
+  }
+
+  @Put('calendar')
+  @RequirePermissions('inspections.manage')
+  upsertDay(
+    @Body() dto: UpsertBusinessCalendarDayDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.deadlines.upsertCalendarDay(dto, principal, request);
+  }
+
+  @Delete('calendar/:date')
+  @RequirePermissions('inspections.manage')
+  removeDay(
+    @Param('date') date: string,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.deadlines.removeCalendarDay(date, principal, request);
+  }
+}

From e25f72ac0aff92b22261125f8b5701da279858fc Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:03:00 -0300
Subject: [PATCH 037/224] feat(f4): register deadline administration

---
 api-v3/src/inspection-reports/inspection-reports.module.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/api-v3/src/inspection-reports/inspection-reports.module.ts b/api-v3/src/inspection-reports/inspection-reports.module.ts
index ff43f14..6f5d076 100644
--- a/api-v3/src/inspection-reports/inspection-reports.module.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.module.ts
@@ -2,6 +2,8 @@ import { Module } from '@nestjs/common';
 import { AuditModule } from '../audit/audit.module';
 import { DocumentDeliveryController } from './document-delivery.controller';
 import { InspectionActPdfService } from './inspection-act-pdf.service';
+import { InspectionDeadlineAdminController } from './inspection-deadline-admin.controller';
+import { InspectionDeadlineAdminService } from './inspection-deadline-admin.service';
 import { InspectionDocumentDeliveryService } from './inspection-document-delivery.service';
 import { InspectionReportWorkflowService } from './inspection-report-workflow.service';
 import { InspectionReportWordService } from './inspection-report-word.service';
@@ -14,6 +16,7 @@ import { SmtpDeliveryService } from './smtp-delivery.service';
   controllers: [
     InspectionReportsController,
     InspectionActReportController,
+    InspectionDeadlineAdminController,
     DocumentDeliveryController,
   ],
   providers: [
@@ -21,6 +24,7 @@ import { SmtpDeliveryService } from './smtp-delivery.service';
     InspectionReportWorkflowService,
     InspectionReportWordService,
     InspectionActPdfService,
+    InspectionDeadlineAdminService,
     InspectionDocumentDeliveryService,
     SmtpDeliveryService,
   ],

From 5c1c046be6657576bf410cd37194bdc165896eaa Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:12:43 -0300
Subject: [PATCH 038/224] F4: add temporal inventory function catalog

---
 ...000100000-f4-inventory-function-history.ts | 80 +++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 api-v3/src/database/migrations/1790000100000-f4-inventory-function-history.ts

diff --git a/api-v3/src/database/migrations/1790000100000-f4-inventory-function-history.ts b/api-v3/src/database/migrations/1790000100000-f4-inventory-function-history.ts
new file mode 100644
index 0000000..c87b657
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000100000-f4-inventory-function-history.ts
@@ -0,0 +1,80 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class F4InventoryFunctionHistory1790000100000 implements MigrationInterface {
+  name = 'F4InventoryFunctionHistory1790000100000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE inventory_functions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        code varchar(120) NOT NULL UNIQUE,
+        name varchar(240) NOT NULL,
+        description text,
+        is_active boolean NOT NULL DEFAULT true,
+        sort_order integer NOT NULL DEFAULT 0,
+        created_by uuid,
+        updated_by uuid,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT fk_inventory_functions_created_by FOREIGN KEY (created_by)
+          REFERENCES users(id) ON DELETE SET NULL,
+        CONSTRAINT fk_inventory_functions_updated_by FOREIGN KEY (updated_by)
+          REFERENCES users(id) ON DELETE SET NULL
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX idx_inventory_functions_active_sort
+      ON inventory_functions(is_active,sort_order,name)
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE inventory_function_assignments (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        asset_id uuid NOT NULL,
+        function_id uuid NOT NULL,
+        valid_from timestamptz NOT NULL,
+        valid_until timestamptz,
+        change_reason text,
+        changed_by uuid,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT fk_inventory_function_assignment_asset FOREIGN KEY (asset_id)
+          REFERENCES assets(id) ON DELETE CASCADE,
+        CONSTRAINT fk_inventory_function_assignment_function FOREIGN KEY (function_id)
+          REFERENCES inventory_functions(id) ON DELETE RESTRICT,
+        CONSTRAINT fk_inventory_function_assignment_user FOREIGN KEY (changed_by)
+          REFERENCES users(id) ON DELETE SET NULL,
+        CONSTRAINT chk_inventory_function_assignment_dates CHECK (
+          valid_until IS NULL OR valid_until > valid_from
+        )
+      )
+    `);
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX uq_inventory_function_assignment_current
+      ON inventory_function_assignments(asset_id)
+      WHERE valid_until IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE INDEX idx_inventory_function_assignment_history
+      ON inventory_function_assignments(asset_id,valid_from DESC,created_at DESC)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX idx_inventory_function_assignment_function
+      ON inventory_function_assignments(function_id,valid_from DESC)
+    `);
+
+    await queryRunner.query(`
+      INSERT INTO inventory_functions(code,name,description,sort_order)
+      VALUES
+        ('BOMBEO_MECANICO_AIB','Bombeo mecánico AIB',
+          'Función técnica de bombeo mecánico mediante aparato individual de bombeo (AIB).',10),
+        ('BOMBEO_MECANICO_ROTAFLEX','Bombeo mecánico Rotaflex',
+          'Función técnica de bombeo mecánico mediante sistema Rotaflex.',20)
+      ON CONFLICT (code) DO NOTHING
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query('DROP TABLE IF EXISTS inventory_function_assignments');
+    await queryRunner.query('DROP TABLE IF EXISTS inventory_functions');
+  }
+}

From 8b4cc99e5319f8c971c20037b426a9d8a378ead6 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:12:57 -0300
Subject: [PATCH 039/224] F4: add inventory function DTOs

---
 .../dto/inventory-function.dto.ts             | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 api-v3/src/asset-master/dto/inventory-function.dto.ts

diff --git a/api-v3/src/asset-master/dto/inventory-function.dto.ts b/api-v3/src/asset-master/dto/inventory-function.dto.ts
new file mode 100644
index 0000000..b47e34a
--- /dev/null
+++ b/api-v3/src/asset-master/dto/inventory-function.dto.ts
@@ -0,0 +1,79 @@
+import { Transform } from 'class-transformer';
+import {
+  IsBoolean,
+  IsISO8601,
+  IsInt,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Max,
+  MaxLength,
+  Min,
+  MinLength,
+} from 'class-validator';
+
+export class CreateInventoryFunctionDto {
+  @Transform(({ value }) => typeof value === 'string' ? value.trim().toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(120)
+  code!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(240)
+  name!: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(4000)
+  description?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  @Max(100000)
+  sortOrder?: number;
+}
+
+export class UpdateInventoryFunctionDto {
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(240)
+  name?: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(4000)
+  description?: string | null;
+
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  @Max(100000)
+  sortOrder?: number;
+}
+
+export class ChangeInventoryFunctionDto {
+  @IsUUID('4')
+  functionId!: string;
+
+  @IsOptional()
+  @IsISO8601({ strict: true })
+  effectiveAt?: string;
+
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
+  @IsString()
+  @MaxLength(4000)
+  reason?: string | null;
+}

From cbe69a8fffaa4f88e0c94594ab13a7c6fb7ad30b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:13:59 -0300
Subject: [PATCH 040/224] F4: implement temporal inventory function changes

---
 .../inventory-function.service.ts             | 352 ++++++++++++++++++
 1 file changed, 352 insertions(+)
 create mode 100644 api-v3/src/asset-master/inventory-function.service.ts

diff --git a/api-v3/src/asset-master/inventory-function.service.ts b/api-v3/src/asset-master/inventory-function.service.ts
new file mode 100644
index 0000000..7cdd581
--- /dev/null
+++ b/api-v3/src/asset-master/inventory-function.service.ts
@@ -0,0 +1,352 @@
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { DataSource, EntityManager } from 'typeorm';
+import { administrationAuditContext } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { AuditAction, AssetVersionChangeType } from '../database/entities';
+import { AssetHistoryService } from './asset-history.service';
+import type {
+  ChangeInventoryFunctionDto,
+  CreateInventoryFunctionDto,
+  UpdateInventoryFunctionDto,
+} from './dto/inventory-function.dto';
+
+interface InventoryFunctionRow {
+  id: string;
+  code: string;
+  name: string;
+  description: string | null;
+  isActive: boolean;
+  sortOrder: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+interface FunctionAssignmentRow {
+  id: string;
+  assetId: string;
+  functionId: string;
+  functionCode: string;
+  functionName: string;
+  validFrom: Date;
+  validUntil: Date | null;
+  reason: string | null;
+  changedBy: string | null;
+  changedByUsername: string | null;
+  createdAt: Date;
+}
+
+interface FunctionEligibleAsset {
+  id: string;
+  code: string;
+  name: string;
+  typeCode: string;
+  typeName: string;
+  familyCode: string | null;
+  familyName: string | null;
+}
+
+function normalized(value: string | null): string {
+  return (value ?? '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+}
+
+@Injectable()
+export class InventoryFunctionService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly audit: AuditService,
+    private readonly history: AssetHistoryService,
+  ) {}
+
+  async list(includeInactive = false): Promise<{ data: InventoryFunctionRow[] }> {
+    const data = await this.dataSource.query(`
+      SELECT id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",
+        created_at AS "createdAt",updated_at AS "updatedAt"
+      FROM inventory_functions
+      ${includeInactive ? '' : 'WHERE is_active=true'}
+      ORDER BY sort_order,name,code
+    `) as InventoryFunctionRow[];
+    return { data };
+  }
+
+  async create(
+    dto: CreateInventoryFunctionDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ): Promise<InventoryFunctionRow> {
+    return this.dataSource.transaction(async (manager) => {
+      const [duplicate] = await manager.query(
+        'SELECT 1 FROM inventory_functions WHERE lower(code)=lower($1) LIMIT 1',
+        [dto.code],
+      ) as unknown[];
+      if (duplicate) {
+        throw new ConflictException({
+          code: 'INVENTORY_FUNCTION_CODE_EXISTS',
+          message: 'Ya existe una función con ese código',
+        });
+      }
+      const [created] = await manager.query(`
+        INSERT INTO inventory_functions(code,name,description,is_active,sort_order,created_by,updated_by)
+        VALUES($1,$2,$3,true,$4,$5,$5)
+        RETURNING id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",
+          created_at AS "createdAt",updated_at AS "updatedAt"
+      `, [dto.code, dto.name, dto.description ?? null, dto.sortOrder ?? 0, principal.userId]) as InventoryFunctionRow[];
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INVENTORY_FUNCTION_CREATED,
+        entityType: 'inventory_function',
+        entityId: created.id,
+        afterData: created as unknown as Record<string, unknown>,
+      }, manager);
+      return created;
+    });
+  }
+
+  async update(
+    id: string,
+    dto: UpdateInventoryFunctionDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ): Promise<InventoryFunctionRow> {
+    if (Object.keys(dto).length === 0) {
+      throw new BadRequestException({ code: 'NO_CHANGES', message: 'No se recibieron cambios' });
+    }
+    return this.dataSource.transaction(async (manager) => {
+      const before = await this.requireFunction(manager, id, false);
+      const [updated] = await manager.query(`
+        UPDATE inventory_functions SET
+          name=COALESCE($2,name),
+          description=CASE WHEN $3::boolean THEN $4 ELSE description END,
+          is_active=COALESCE($5,is_active),
+          sort_order=COALESCE($6,sort_order),
+          updated_by=$7,updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1
+        RETURNING id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",
+          created_at AS "createdAt",updated_at AS "updatedAt"
+      `, [
+        id,
+        dto.name ?? null,
+        dto.description !== undefined,
+        dto.description ?? null,
+        dto.isActive ?? null,
+        dto.sortOrder ?? null,
+        principal.userId,
+      ]) as InventoryFunctionRow[];
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INVENTORY_FUNCTION_UPDATED,
+        entityType: 'inventory_function',
+        entityId: id,
+        beforeData: before as unknown as Record<string, unknown>,
+        afterData: updated as unknown as Record<string, unknown>,
+      }, manager);
+      return updated;
+    });
+  }
+
+  async getForAsset(assetId: string) {
+    return this.dataSource.transaction((manager) => this.getForAssetWithManager(manager, assetId));
+  }
+
+  async changeForAsset(
+    assetId: string,
+    dto: ChangeInventoryFunctionDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    return this.dataSource.transaction(async (manager) => {
+      const asset = await this.requireEligibleAsset(manager, assetId, true);
+      const nextFunction = await this.requireFunction(manager, dto.functionId, true);
+      const effectiveAt = dto.effectiveAt ? new Date(dto.effectiveAt) : new Date();
+      if (!Number.isFinite(effectiveAt.getTime())) {
+        throw new BadRequestException({
+          code: 'INVENTORY_FUNCTION_EFFECTIVE_DATE_INVALID',
+          message: 'La fecha efectiva del cambio de función no es válida',
+        });
+      }
+      if (effectiveAt.getTime() > Date.now() + 60_000) {
+        throw new BadRequestException({
+          code: 'INVENTORY_FUNCTION_FUTURE_DATE_NOT_ALLOWED',
+          message: 'El cambio de función no puede registrarse con fecha futura',
+        });
+      }
+
+      const current = await this.currentAssignment(manager, assetId, true);
+      if (current?.functionId === nextFunction.id) {
+        return this.getForAssetWithManager(manager, assetId);
+      }
+      if (current && effectiveAt.getTime() <= new Date(current.validFrom).getTime()) {
+        throw new ConflictException({
+          code: 'INVENTORY_FUNCTION_EFFECTIVE_DATE_OVERLAP',
+          message: 'La fecha efectiva debe ser posterior al inicio de la función vigente',
+        });
+      }
+
+      if (current) {
+        await manager.query(`
+          UPDATE inventory_function_assignments
+          SET valid_until=$2
+          WHERE id=$1 AND valid_until IS NULL
+        `, [current.id, effectiveAt]);
+      }
+      await manager.query(`
+        INSERT INTO inventory_function_assignments(
+          asset_id,function_id,valid_from,change_reason,changed_by
+        ) VALUES($1,$2,$3,$4,$5)
+      `, [assetId, nextFunction.id, effectiveAt, dto.reason ?? null, principal.userId]);
+      await manager.query(`
+        UPDATE assets SET updated_by=$2,updated_at=CURRENT_TIMESTAMP WHERE id=$1
+      `, [assetId, principal.userId]);
+      const versionNumber = await this.history.capture(
+        manager,
+        assetId,
+        AssetVersionChangeType.FUNCTION_CHANGED,
+        principal,
+        request,
+      );
+      const after = await this.getForAssetWithManager(manager, assetId);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.ASSET_FUNCTION_CHANGED,
+        entityType: 'asset',
+        entityId: assetId,
+        beforeData: current ? {
+          functionId: current.functionId,
+          functionCode: current.functionCode,
+          functionName: current.functionName,
+          validFrom: current.validFrom,
+        } : { functionId: null },
+        afterData: {
+          functionId: nextFunction.id,
+          functionCode: nextFunction.code,
+          functionName: nextFunction.name,
+          effectiveAt,
+          reason: dto.reason ?? null,
+        },
+        metadata: {
+          inventoryCode: asset.code,
+          inventoryName: asset.name,
+          versionNumber,
+          temporal: true,
+        },
+      }, manager);
+      return after;
+    });
+  }
+
+  private async getForAssetWithManager(manager: EntityManager, assetId: string) {
+    const asset = await this.requireEligibleAsset(manager, assetId, false);
+    const currentFunction = await this.currentAssignment(manager, assetId, false);
+    const history = await manager.query(`
+      SELECT assignment.id,assignment.asset_id AS "assetId",assignment.function_id AS "functionId",
+        fn.code AS "functionCode",fn.name AS "functionName",
+        assignment.valid_from AS "validFrom",assignment.valid_until AS "validUntil",
+        assignment.change_reason AS reason,assignment.changed_by AS "changedBy",
+        actor.username AS "changedByUsername",assignment.created_at AS "createdAt"
+      FROM inventory_function_assignments assignment
+      JOIN inventory_functions fn ON fn.id=assignment.function_id
+      LEFT JOIN users actor ON actor.id=assignment.changed_by
+      WHERE assignment.asset_id=$1
+      ORDER BY assignment.valid_from DESC,assignment.created_at DESC
+    `, [assetId]) as FunctionAssignmentRow[];
+    return {
+      asset: {
+        id: asset.id,
+        code: asset.code,
+        name: asset.name,
+        typeCode: asset.typeCode,
+        typeName: asset.typeName,
+        familyCode: asset.familyCode,
+        familyName: asset.familyName,
+      },
+      currentFunction,
+      history,
+    };
+  }
+
+  private async currentAssignment(
+    manager: EntityManager,
+    assetId: string,
+    lock: boolean,
+  ): Promise<FunctionAssignmentRow | null> {
+    const [row] = await manager.query(`
+      SELECT assignment.id,assignment.asset_id AS "assetId",assignment.function_id AS "functionId",
+        fn.code AS "functionCode",fn.name AS "functionName",
+        assignment.valid_from AS "validFrom",assignment.valid_until AS "validUntil",
+        assignment.change_reason AS reason,assignment.changed_by AS "changedBy",
+        actor.username AS "changedByUsername",assignment.created_at AS "createdAt"
+      FROM inventory_function_assignments assignment
+      JOIN inventory_functions fn ON fn.id=assignment.function_id
+      LEFT JOIN users actor ON actor.id=assignment.changed_by
+      WHERE assignment.asset_id=$1 AND assignment.valid_until IS NULL
+      ${lock ? 'FOR UPDATE OF assignment' : ''}
+    `, [assetId]) as FunctionAssignmentRow[];
+    return row ?? null;
+  }
+
+  private async requireFunction(
+    manager: EntityManager,
+    id: string,
+    active: boolean,
+  ): Promise<InventoryFunctionRow> {
+    const [row] = await manager.query(`
+      SELECT id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",
+        created_at AS "createdAt",updated_at AS "updatedAt"
+      FROM inventory_functions
+      WHERE id=$1 ${active ? 'AND is_active=true' : ''}
+    `, [id]) as InventoryFunctionRow[];
+    if (!row) {
+      throw new NotFoundException({
+        code: 'INVENTORY_FUNCTION_NOT_FOUND',
+        message: active ? 'La función seleccionada no existe o está inactiva' : 'Función no encontrada',
+      });
+    }
+    return row;
+  }
+
+  private async requireEligibleAsset(
+    manager: EntityManager,
+    assetId: string,
+    lock: boolean,
+  ): Promise<FunctionEligibleAsset> {
+    const [asset] = await manager.query(`
+      SELECT asset.id,asset.code,asset.name,
+        asset_type.code AS "typeCode",asset_type.name AS "typeName",
+        family.code AS "familyCode",family.name AS "familyName"
+      FROM assets asset
+      JOIN asset_types asset_type ON asset_type.id=asset.asset_type_id
+      LEFT JOIN inventory_families family ON family.id=asset.inventory_family_id
+      WHERE asset.id=$1
+      ${lock ? 'FOR UPDATE OF asset' : ''}
+    `, [assetId]) as FunctionEligibleAsset[];
+    if (!asset) {
+      throw new NotFoundException({ code: 'ASSET_NOT_FOUND', message: 'Inventario no encontrado' });
+    }
+    const values = [asset.typeCode, asset.typeName, asset.familyCode, asset.familyName].map(normalized);
+    const eligible = values.some((value) =>
+      value === 'estacion'
+      || value === 'subestacion'
+      || value.includes('estacion ')
+      || value.includes('subestacion ')
+      || value.endsWith(' estacion')
+      || value.endsWith(' subestacion'),
+    );
+    if (!eligible) {
+      throw new ConflictException({
+        code: 'INVENTORY_FUNCTION_CHANGE_NOT_ALLOWED',
+        message: 'El cambio de función sólo está habilitado para Inventarios de Estación o Subestación',
+      });
+    }
+    return asset;
+  }
+}

From e02a3d9b58919b13c9e38446810268ada0d8437a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:14:09 -0300
Subject: [PATCH 041/224] F4: expose inventory function catalog and history

---
 .../inventory-function.controller.ts          | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 api-v3/src/asset-master/inventory-function.controller.ts

diff --git a/api-v3/src/asset-master/inventory-function.controller.ts b/api-v3/src/asset-master/inventory-function.controller.ts
new file mode 100644
index 0000000..618d5c4
--- /dev/null
+++ b/api-v3/src/asset-master/inventory-function.controller.ts
@@ -0,0 +1,69 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Query,
+  Req,
+} from '@nestjs/common';
+import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
+import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import {
+  ChangeInventoryFunctionDto,
+  CreateInventoryFunctionDto,
+  UpdateInventoryFunctionDto,
+} from './dto/inventory-function.dto';
+import { InventoryFunctionService } from './inventory-function.service';
+
+@Controller()
+export class InventoryFunctionController {
+  constructor(private readonly functions: InventoryFunctionService) {}
+
+  @Get('inventory-functions')
+  @RequirePermissions('assets.read')
+  list(@Query('includeInactive') includeInactive?: string) {
+    return this.functions.list(includeInactive === 'true');
+  }
+
+  @Post('inventory-functions')
+  @RequirePermissions('asset_types.manage')
+  create(
+    @Body() dto: CreateInventoryFunctionDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.functions.create(dto, principal, request);
+  }
+
+  @Patch('inventory-functions/:id')
+  @RequirePermissions('asset_types.manage')
+  update(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Body() dto: UpdateInventoryFunctionDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.functions.update(id, dto, principal, request);
+  }
+
+  @Get('assets/:id/function-history')
+  @RequirePermissions('assets.read_history')
+  history(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
+    return this.functions.getForAsset(id);
+  }
+
+  @Post('assets/:id/function')
+  @RequirePermissions('assets.update')
+  change(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Body() dto: ChangeInventoryFunctionDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.functions.changeForAsset(id, dto, principal, request);
+  }
+}

From 0833746e1d9407626cf4f9b1781215bd50204098 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:14:27 -0300
Subject: [PATCH 042/224] F4: wire inventory function workflow

---
 api-v3/src/asset-master/asset-master.module.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/api-v3/src/asset-master/asset-master.module.ts b/api-v3/src/asset-master/asset-master.module.ts
index b649323..f4484e3 100644
--- a/api-v3/src/asset-master/asset-master.module.ts
+++ b/api-v3/src/asset-master/asset-master.module.ts
@@ -29,6 +29,8 @@ import { InventoryFamilyCatalogService } from './inventory-family-catalog.servic
 import { FieldInventoryMergeController, InventoryMergeController } from './inventory-merge.controller';
 import { InventoryMergeService } from './inventory-merge.service';
 import { MergedInventoryDossierService } from './merged-inventory-dossier.service';
+import { InventoryFunctionController } from './inventory-function.controller';
+import { InventoryFunctionService } from './inventory-function.service';
 
 @Module({
   imports: [AuditModule],
@@ -37,6 +39,7 @@ import { MergedInventoryDossierService } from './merged-inventory-dossier.servic
     AssetsController,
     InventoryStructureController,
     InventoryFamilyCatalogController,
+    InventoryFunctionController,
     InventoryMergeController,
     FieldInventoryMergeController,
     AssetGeometriesController,
@@ -53,6 +56,7 @@ import { MergedInventoryDossierService } from './merged-inventory-dossier.servic
     AssetsService,
     InventoryStructureService,
     InventoryFamilyCatalogService,
+    InventoryFunctionService,
     InventoryMergeService,
     MergedInventoryDossierService,
     AssetGeometriesService,
@@ -67,6 +71,7 @@ import { MergedInventoryDossierService } from './merged-inventory-dossier.servic
   exports: [
     AssetHistoryService,
     AssetsService,
+    InventoryFunctionService,
     InventoryMergeService,
     MergedInventoryDossierService,
     AssetGeometriesService,

From 4d5c83732ecd9496c222fade5cd02b705b9c1858 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:14:42 -0300
Subject: [PATCH 043/224] F4: version inventory function changes

---
 api-v3/src/database/entities/asset-version.entity.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/api-v3/src/database/entities/asset-version.entity.ts b/api-v3/src/database/entities/asset-version.entity.ts
index 6c9e241..0f041be 100644
--- a/api-v3/src/database/entities/asset-version.entity.ts
+++ b/api-v3/src/database/entities/asset-version.entity.ts
@@ -5,6 +5,7 @@ export enum AssetVersionChangeType {
   CREATED = 'CREATED',
   UPDATED = 'UPDATED',
   CONTEXT_CHANGED = 'CONTEXT_CHANGED',
+  FUNCTION_CHANGED = 'FUNCTION_CHANGED',
   STATUS_CHANGED = 'STATUS_CHANGED',
   OPERATIONAL_STATUS_CHANGED = 'OPERATIONAL_STATUS_CHANGED',
   REGISTRY_UPDATED = 'REGISTRY_UPDATED',

From 88179eb67cc08ba1be87a512195d541bdf9ff2bb Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:15:15 -0300
Subject: [PATCH 044/224] F4: audit inventory function changes

---
 api-v3/src/database/entities/audit-event.entity.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/api-v3/src/database/entities/audit-event.entity.ts b/api-v3/src/database/entities/audit-event.entity.ts
index 6fabafe..42a616e 100644
--- a/api-v3/src/database/entities/audit-event.entity.ts
+++ b/api-v3/src/database/entities/audit-event.entity.ts
@@ -35,6 +35,9 @@ export enum AuditAction {
   ASSET_FIELD_DISCOVERY_REJECTED = 'ASSET_FIELD_DISCOVERY_REJECTED',
   ASSET_UPDATED = 'ASSET_UPDATED',
   ASSET_CONTEXT_CHANGED = 'ASSET_CONTEXT_CHANGED',
+  ASSET_FUNCTION_CHANGED = 'ASSET_FUNCTION_CHANGED',
+  INVENTORY_FUNCTION_CREATED = 'INVENTORY_FUNCTION_CREATED',
+  INVENTORY_FUNCTION_UPDATED = 'INVENTORY_FUNCTION_UPDATED',
   ASSET_INFORMATION_STATUS_CHANGED = 'ASSET_INFORMATION_STATUS_CHANGED',
   ASSET_OPERATIONAL_STATUS_CHANGED = 'ASSET_OPERATIONAL_STATUS_CHANGED',
   ASSET_REGISTRY_UPDATED = 'ASSET_REGISTRY_UPDATED',

From a836c7535ad9f0b33f574834aab989d4e128d45f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:17:33 -0300
Subject: [PATCH 045/224] F4: include technical function in merged inventory
 dossier

---
 .../merged-inventory-dossier.service.ts       | 37 ++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/api-v3/src/asset-master/merged-inventory-dossier.service.ts b/api-v3/src/asset-master/merged-inventory-dossier.service.ts
index 7a09038..7309767 100644
--- a/api-v3/src/asset-master/merged-inventory-dossier.service.ts
+++ b/api-v3/src/asset-master/merged-inventory-dossier.service.ts
@@ -1,5 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { AssetsService } from './assets.service';
+import { InventoryFunctionService } from './inventory-function.service';
 import { InventoryMergeService } from './inventory-merge.service';
 
 type LooseRecord = Record<string, any>;
@@ -29,6 +30,7 @@ export class MergedInventoryDossierService {
   constructor(
     private readonly assets: AssetsService,
     private readonly merges: InventoryMergeService,
+    private readonly functions: InventoryFunctionService,
   ) {}
 
   async dossier(requestedAssetId: string): Promise<Record<string, unknown>> {
@@ -44,7 +46,8 @@ export class MergedInventoryDossierService {
     const dossiers = await Promise.all(inventoryIds.map(async (assetId) => {
       const dossier = await this.assets.dossier(assetId) as LooseRecord;
       const identity = dossier.asset as LooseRecord;
-      return { assetId, identity, dossier };
+      const functionDossier = await this.functions.getForAsset(assetId).catch(() => null) as LooseRecord | null;
+      return { assetId, identity, dossier, functionDossier };
     }));
 
     const enrich = (entry: LooseRecord, identity: LooseRecord): LooseRecord => ({
@@ -75,6 +78,15 @@ export class MergedInventoryDossierService {
     const media = sortDesc(collect('media'), ['capturedAt', 'createdAt']);
     const versions = sortDesc(collect('versions'), ['occurredAt']);
 
+    const functionHistory = sortDesc(
+      dossiers.flatMap(({ identity, functionDossier }) =>
+        (((functionDossier?.history ?? []) as LooseRecord[]).map((entry) => enrich(entry, identity))),
+      ),
+      ['validFrom', 'createdAt'],
+    );
+    const canonicalFunctionDossier = dossiers.find((item) => item.assetId === canonical.id)?.functionDossier ?? null;
+    const currentFunction = canonicalFunctionDossier?.currentFunction ?? null;
+
     const timelineSource: LooseRecord[] = dossiers.flatMap(({ identity, dossier }) =>
       ((dossier.timeline ?? []) as LooseRecord[]).map((event): LooseRecord => ({
         ...event,
@@ -91,6 +103,25 @@ export class MergedInventoryDossierService {
     );
     const timeline: LooseRecord[] = dedupeById<LooseRecord>(timelineSource);
 
+    for (const assignment of functionHistory) {
+      timeline.push({
+        id: `function:${String(assignment.id)}`,
+        kind: 'FUNCTION_CHANGED',
+        occurredAt: assignment.validFrom,
+        title: `Cambio de función · ${String(assignment.functionName)}`,
+        description: assignment.reason ?? null,
+        meta: {
+          functionId: assignment.functionId,
+          functionCode: assignment.functionCode,
+          functionName: assignment.functionName,
+          validFrom: assignment.validFrom,
+          validUntil: assignment.validUntil,
+          changedByUsername: assignment.changedByUsername,
+          historicalInventory: assignment.historicalInventory,
+        },
+      });
+    }
+
     for (const alias of aliases) {
       timeline.push({
         id: `merge:${String(alias.id)}:${String(alias.mergedAt)}`,
@@ -121,6 +152,7 @@ export class MergedInventoryDossierService {
         code: canonical.code,
         name: canonical.name,
         commonName: dossiers.find((item) => item.assetId === canonical.id)?.identity?.commonName ?? null,
+        currentFunction,
       },
       requestedAsset: {
         id: requested.id,
@@ -146,7 +178,10 @@ export class MergedInventoryDossierService {
         documents: documents.length + media.filter((item) => item.kind === 'DOCUMENT').length,
         photos: evidence.filter((item) => item.kind === 'PHOTO').length + media.filter((item) => item.kind === 'PHOTO').length,
         reports: reports.length + inspectionReports.length,
+        functionChanges: functionHistory.length,
       },
+      currentFunction,
+      functionHistory,
       visits,
       acts,
       findings,

From c3c798baed8c671e0e5287078b3d95997b3dea91 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:17:46 -0300
Subject: [PATCH 046/224] F4: require explicit Act for every field finding

---
 .../src/inspection-visits/dto/create-field-finding.dto.ts   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/api-v3/src/inspection-visits/dto/create-field-finding.dto.ts b/api-v3/src/inspection-visits/dto/create-field-finding.dto.ts
index 8adab5f..abbce3a 100644
--- a/api-v3/src/inspection-visits/dto/create-field-finding.dto.ts
+++ b/api-v3/src/inspection-visits/dto/create-field-finding.dto.ts
@@ -18,12 +18,11 @@ const optionalText = ({ value }: { value: unknown }) =>
 /**
  * Hallazgo capturado desde la APK sobre un Inventario ya seleccionado.
  * El assetId se toma de la URL para evitar inconsistencias entre pantalla y payload.
- * `actId` queda opcional sólo para compatibilidad con Android 0.11.0; F3.2 siempre lo envía.
+ * El Acta es obligatoria: nunca se infiere ni se adivina en backend.
  */
 export class CreateFieldFindingDto {
-  @IsOptional()
   @IsUUID('4')
-  actId?: string;
+  actId!: string;
 
   @IsOptional()
   @Transform(optionalText)
@@ -43,6 +42,7 @@ export class CreateFieldFindingDto {
   @MaxLength(12000)
   customLegalBasis?: string | null;
 
+  /** Descripción libre escrita por el inspector. Nunca se reemplaza por el catálogo. */
   @Transform(({ value }) => (typeof value === 'string' ? value.trim() : value))
   @IsString()
   @MinLength(1)

From 2b63638c357d0dade20541092b984623b182656f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:17:56 -0300
Subject: [PATCH 047/224] F4: remove legacy Act inference from finding queries

---
 .../dto/field-finding-act-query.dto.ts                | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/api-v3/src/inspection-visits/dto/field-finding-act-query.dto.ts b/api-v3/src/inspection-visits/dto/field-finding-act-query.dto.ts
index 5df166f..0a570fc 100644
--- a/api-v3/src/inspection-visits/dto/field-finding-act-query.dto.ts
+++ b/api-v3/src/inspection-visits/dto/field-finding-act-query.dto.ts
@@ -1,12 +1,7 @@
-import { IsOptional, IsUUID } from 'class-validator';
+import { IsUUID } from 'class-validator';
 
-/**
- * Selección explícita del Acta activa desde la APK.
- * `actId` queda opcional sólo durante la transición desde Android 0.11.0;
- * F3.2 móvil siempre lo informa.
- */
+/** Selección explícita y obligatoria del Acta activa desde la APK. */
 export class FieldFindingActQueryDto {
-  @IsOptional()
   @IsUUID('4')
-  actId?: string;
+  actId!: string;
 }

From 83ab2d4060b0073ad658822276c2ff28173b156b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:18:43 -0300
Subject: [PATCH 048/224] F4: add explicit inspection cancellation DTO

---
 .../dto/cancel-inspection-visit.dto.ts                 | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 api-v3/src/inspection-visits/dto/cancel-inspection-visit.dto.ts

diff --git a/api-v3/src/inspection-visits/dto/cancel-inspection-visit.dto.ts b/api-v3/src/inspection-visits/dto/cancel-inspection-visit.dto.ts
new file mode 100644
index 0000000..4116c81
--- /dev/null
+++ b/api-v3/src/inspection-visits/dto/cancel-inspection-visit.dto.ts
@@ -0,0 +1,10 @@
+import { Transform } from 'class-transformer';
+import { IsString, MaxLength, MinLength } from 'class-validator';
+
+export class CancelInspectionVisitDto {
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(10)
+  @MaxLength(4000)
+  reason!: string;
+}

From 577e267f498c48ca45ff8b0e17d16f43d2aa22be Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:19:12 -0300
Subject: [PATCH 049/224] F4: implement explicit inspection lifecycle

---
 .../inspection-visit-lifecycle.service.ts     | 297 ++++++++++++++++++
 1 file changed, 297 insertions(+)
 create mode 100644 api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts

diff --git a/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
new file mode 100644
index 0000000..e420083
--- /dev/null
+++ b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
@@ -0,0 +1,297 @@
+import {
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { DataSource, EntityManager } from 'typeorm';
+import { administrationAuditContext } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { AuditAction, InspectionVisit, InspectionVisitStatus } from '../database/entities';
+import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
+import type { CancelInspectionVisitDto } from './dto/cancel-inspection-visit.dto';
+import type { CloseInspectionVisitDto } from './dto/close-inspection-visit.dto';
+import { InspectionVisitsService } from './inspection-visits.service';
+
+interface PendingActRow {
+  id: string;
+  code: string;
+  status: string;
+}
+
+@Injectable()
+export class InspectionVisitLifecycleService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly audit: AuditService,
+    private readonly visits: InspectionVisitsService,
+  ) {}
+
+  async plan(
+    id: string,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    await this.dataSource.transaction(async (manager) => {
+      const visit = await this.lockVisit(manager, id);
+      if (visit.status !== InspectionVisitStatus.DRAFT) {
+        throw new ConflictException({
+          code: 'INSPECTION_NOT_DRAFT',
+          message: 'Sólo una Inspección en borrador puede planificarse',
+        });
+      }
+      await this.validatePlanningContext(manager, visit);
+      const before = visit.status;
+      visit.status = InspectionVisitStatus.PLANNED;
+      visit.cancellationReason = null;
+      visit.updatedBy = principal.userId;
+      await manager.getRepository(InspectionVisit).save(visit);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_VISIT_STATUS_CHANGED,
+        entityType: 'inspection_visit',
+        entityId: id,
+        beforeData: { status: before },
+        afterData: { status: InspectionVisitStatus.PLANNED },
+        metadata: { transition: 'PLAN' },
+      }, manager);
+    });
+    return this.visits.getById(id);
+  }
+
+  async start(
+    id: string,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    assertMobileInspector(principal);
+    await this.dataSource.transaction(async (manager) => {
+      const visit = await this.lockVisit(manager, id);
+      if (visit.status !== InspectionVisitStatus.PLANNED) {
+        throw new ConflictException({
+          code: 'INSPECTION_NOT_PLANNED',
+          message: 'La Inspección debe estar planificada antes de iniciarse',
+        });
+      }
+      await this.validatePlanningContext(manager, visit);
+      await this.assertActorAssigned(manager, visit, principal);
+      const startedAt = new Date();
+      visit.status = InspectionVisitStatus.IN_PROGRESS;
+      visit.actualStartedAt = startedAt;
+      visit.updatedBy = principal.userId;
+      await manager.getRepository(InspectionVisit).save(visit);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_VISIT_STARTED,
+        entityType: 'inspection_visit',
+        entityId: id,
+        beforeData: { status: InspectionVisitStatus.PLANNED, actualStartedAt: null },
+        afterData: { status: InspectionVisitStatus.IN_PROGRESS, actualStartedAt: startedAt },
+        metadata: { transition: 'START', source: 'ANDROID' },
+      }, manager);
+    });
+    return this.visits.getById(id);
+  }
+
+  async close(
+    id: string,
+    dto: CloseInspectionVisitDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    assertMobileInspector(principal);
+    await this.dataSource.transaction(async (manager) => {
+      const visit = await this.lockVisit(manager, id);
+      if (visit.status !== InspectionVisitStatus.IN_PROGRESS) {
+        throw new ConflictException({
+          code: 'INSPECTION_NOT_IN_PROGRESS',
+          message: 'La Inspección debe estar en curso para cerrarse',
+        });
+      }
+      await this.assertActorAssigned(manager, visit, principal);
+
+      const acts = await manager.query(`
+        SELECT id,code,status
+        FROM inspection_acts
+        WHERE visit_id=$1 AND status<>'CANCELLED'
+        ORDER BY occurred_at,created_at,id
+        FOR UPDATE
+      `, [id]) as PendingActRow[];
+      if (acts.length === 0) {
+        throw new ConflictException({
+          code: 'INSPECTION_REQUIRES_ACT',
+          message: 'La Inspección debe tener al menos un Acta antes de cerrarse',
+        });
+      }
+      const pending = acts.filter((act) => act.status !== 'SEALED');
+      if (pending.length > 0) {
+        throw new ConflictException({
+          code: 'INSPECTION_ACTS_NOT_SEALED',
+          message: 'Todas las Actas deben estar SELLADAS antes de cerrar la Inspección',
+          pendingActs: pending.map((act) => ({ id: act.id, code: act.code, status: act.status })),
+        });
+      }
+
+      const serverClosedAt = new Date();
+      const clientClosedAt = new Date(dto.clientClosedAt);
+      if (!Number.isFinite(clientClosedAt.getTime())) {
+        throw new BadRequestException({
+          code: 'INSPECTION_CLOSE_TIME_INVALID',
+          message: 'La fecha de cierre informada por el dispositivo no es válida',
+        });
+      }
+      if (visit.actualStartedAt && clientClosedAt.getTime() < visit.actualStartedAt.getTime()) {
+        throw new BadRequestException({
+          code: 'INSPECTION_CLOSE_BEFORE_START',
+          message: 'La fecha de cierre no puede ser anterior al inicio de la Inspección',
+        });
+      }
+      if (clientClosedAt.getTime() > serverClosedAt.getTime() + 24 * 60 * 60 * 1000) {
+        throw new BadRequestException({
+          code: 'INSPECTION_CLOSE_TIME_IN_FUTURE',
+          message: 'La fecha del dispositivo no puede estar más de 24 horas en el futuro',
+        });
+      }
+
+      visit.status = InspectionVisitStatus.CLOSED;
+      visit.actualClosedAt = serverClosedAt;
+      visit.updatedBy = principal.userId;
+      await manager.getRepository(InspectionVisit).save(visit);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_VISIT_STATUS_CHANGED,
+        entityType: 'inspection_visit',
+        entityId: id,
+        beforeData: { status: InspectionVisitStatus.IN_PROGRESS },
+        afterData: {
+          status: InspectionVisitStatus.CLOSED,
+          clientClosedAt: clientClosedAt.toISOString(),
+          serverClosedAt: serverClosedAt.toISOString(),
+          sealedActs: acts.length,
+        },
+        metadata: {
+          transition: 'CLOSE',
+          source: 'ANDROID',
+          allActsSealed: true,
+        },
+      }, manager);
+    });
+    return this.visits.getById(id);
+  }
+
+  async cancel(
+    id: string,
+    dto: CancelInspectionVisitDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    await this.dataSource.transaction(async (manager) => {
+      const visit = await this.lockVisit(manager, id);
+      if (![InspectionVisitStatus.DRAFT, InspectionVisitStatus.PLANNED, InspectionVisitStatus.IN_PROGRESS].includes(visit.status)) {
+        throw new ConflictException({
+          code: 'INSPECTION_CANNOT_CANCEL',
+          message: 'La Inspección ya no puede cancelarse en su estado actual',
+        });
+      }
+      const [sealedAct] = await manager.query(`
+        SELECT 1 FROM inspection_acts
+        WHERE visit_id=$1 AND status='SEALED'
+        LIMIT 1
+      `, [id]) as unknown[];
+      if (sealedAct) {
+        throw new ConflictException({
+          code: 'INSPECTION_WITH_SEALED_ACT_CANNOT_CANCEL',
+          message: 'Una Inspección con Actas SELLADAS no puede cancelarse',
+        });
+      }
+      const before = visit.status;
+      visit.status = InspectionVisitStatus.CANCELLED;
+      visit.cancellationReason = dto.reason;
+      visit.updatedBy = principal.userId;
+      await manager.getRepository(InspectionVisit).save(visit);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_VISIT_STATUS_CHANGED,
+        entityType: 'inspection_visit',
+        entityId: id,
+        beforeData: { status: before },
+        afterData: { status: InspectionVisitStatus.CANCELLED, cancellationReason: dto.reason },
+        metadata: { transition: 'CANCEL' },
+      }, manager);
+    });
+    return this.visits.getById(id);
+  }
+
+  private async lockVisit(manager: EntityManager, id: string): Promise<InspectionVisit> {
+    const visit = await manager.getRepository(InspectionVisit)
+      .createQueryBuilder('visit')
+      .where('visit.id=:id', { id })
+      .setLock('pessimistic_write')
+      .getOne();
+    if (!visit) {
+      throw new NotFoundException({ code: 'INSPECTION_NOT_FOUND', message: 'Inspección no encontrada' });
+    }
+    return visit;
+  }
+
+  private async validatePlanningContext(manager: EntityManager, visit: InspectionVisit): Promise<void> {
+    if (!visit.operationalAreaId || !visit.operatorCompanyId || !visit.leadInspectorUserId || !visit.plannedStartAt) {
+      throw new ConflictException({
+        code: 'INSPECTION_PLANNING_INCOMPLETE',
+        message: 'Definí Área/Yacimiento, Operadora, Inspector responsable y fecha de inicio antes de planificar',
+      });
+    }
+    const [relation] = await manager.query(`
+      SELECT 1
+      FROM area_company_relations
+      WHERE area_id=$1 AND company_id=$2
+        AND relation_role='OPERATOR'
+        AND valid_from<=CURRENT_TIMESTAMP
+        AND (valid_until IS NULL OR valid_until>CURRENT_TIMESTAMP)
+      LIMIT 1
+    `, [visit.operationalAreaId, visit.operatorCompanyId]) as unknown[];
+    if (!relation) {
+      throw new ConflictException({
+        code: 'INSPECTION_OPERATOR_RELATION_INVALID',
+        message: 'La Operadora seleccionada no tiene una relación operativa vigente con el Área/Yacimiento',
+      });
+    }
+    const [inspector] = await manager.query(`
+      SELECT 1
+      FROM users user_account
+      JOIN user_roles user_role ON user_role.user_id=user_account.id
+      JOIN role_permissions role_permission ON role_permission.role_id=user_role.role_id
+      JOIN permissions permission ON permission.id=role_permission.permission_id
+      WHERE user_account.id=$1 AND user_account.status='ACTIVE'
+        AND permission.code='inspections.execute'
+      LIMIT 1
+    `, [visit.leadInspectorUserId]) as unknown[];
+    if (!inspector) {
+      throw new ConflictException({
+        code: 'INSPECTION_LEAD_INVALID',
+        message: 'El Inspector responsable no está activo o no puede ejecutar Inspecciones',
+      });
+    }
+  }
+
+  private async assertActorAssigned(
+    manager: EntityManager,
+    visit: InspectionVisit,
+    principal: AuthPrincipal,
+  ): Promise<void> {
+    if (principal.permissions.includes('inspections.manage')) return;
+    const [member] = await manager.query(`
+      SELECT 1 FROM inspection_visit_members
+      WHERE visit_id=$1 AND user_id=$2 AND included=true
+      LIMIT 1
+    `, [visit.id, principal.userId]) as unknown[];
+    if (!member && visit.leadInspectorUserId !== principal.userId) {
+      throw new ForbiddenException({
+        code: 'INSPECTION_NOT_ASSIGNED',
+        message: 'La Inspección no está asignada al usuario actual',
+      });
+    }
+  }
+}

From fcf52c60ff1a3864a14b06804368cb1589b9e4f1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:19:22 -0300
Subject: [PATCH 050/224] F4: wire explicit inspection lifecycle

---
 api-v3/src/inspection-visits/inspection-visits.module.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/api-v3/src/inspection-visits/inspection-visits.module.ts b/api-v3/src/inspection-visits/inspection-visits.module.ts
index 46e3326..0c48c7f 100644
--- a/api-v3/src/inspection-visits/inspection-visits.module.ts
+++ b/api-v3/src/inspection-visits/inspection-visits.module.ts
@@ -7,6 +7,7 @@ import { FieldFindingsController } from './field-findings.controller';
 import { FieldFindingsService } from './field-findings.service';
 import { FieldInventoryController } from './field-inventory.controller';
 import { FieldInventoryService } from './field-inventory.service';
+import { InspectionVisitLifecycleService } from './inspection-visit-lifecycle.service';
 import { InspectionVisitsController } from './inspection-visits.controller';
 import { InspectionVisitsService } from './inspection-visits.service';
 
@@ -15,6 +16,7 @@ import { InspectionVisitsService } from './inspection-visits.service';
   controllers: [InspectionVisitsController, FieldInventoryController, FieldFindingsController],
   providers: [
     InspectionVisitsService,
+    InspectionVisitLifecycleService,
     FieldInventoryService,
     F3FieldInventoryStructureService,
     FieldFindingsService,

From 5e14ffda17870445cae715704d9899755af05c42 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:19:42 -0300
Subject: [PATCH 051/224] F4: expose explicit inspection lifecycle endpoints

---
 .../inspection-visits.controller.ts           | 30 ++++++++++++++-----
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/api-v3/src/inspection-visits/inspection-visits.controller.ts b/api-v3/src/inspection-visits/inspection-visits.controller.ts
index 5fb0c86..4ded255 100644
--- a/api-v3/src/inspection-visits/inspection-visits.controller.ts
+++ b/api-v3/src/inspection-visits/inspection-visits.controller.ts
@@ -13,7 +13,7 @@ import {
 import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
 import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { ChangeInspectionVisitStatusDto } from './dto/change-inspection-visit-status.dto';
+import { CancelInspectionVisitDto } from './dto/cancel-inspection-visit.dto';
 import { CloseInspectionVisitDto } from './dto/close-inspection-visit.dto';
 import { CreateInspectionVisitDto } from './dto/create-inspection-visit.dto';
 import { ExcludeInspectionVisitAssetDto } from './dto/exclude-inspection-visit-asset.dto';
@@ -21,11 +21,15 @@ import { ListInspectionVisitsQueryDto } from './dto/list-inspection-visits-query
 import { ReplaceInspectionVisitAssetsDto } from './dto/replace-inspection-visit-assets.dto';
 import { ReplaceInspectionVisitTeamDto } from './dto/replace-inspection-visit-team.dto';
 import { UpdateInspectionVisitDto } from './dto/update-inspection-visit.dto';
+import { InspectionVisitLifecycleService } from './inspection-visit-lifecycle.service';
 import { InspectionVisitsService } from './inspection-visits.service';
 
 @Controller('inspection-visits')
 export class InspectionVisitsController {
-  constructor(private readonly visits: InspectionVisitsService) {}
+  constructor(
+    private readonly visits: InspectionVisitsService,
+    private readonly lifecycle: InspectionVisitLifecycleService,
+  ) {}
 
   @Get()
   @RequirePermissions('inspections.read')
@@ -135,15 +139,14 @@ export class InspectionVisitsController {
     return this.visits.replaceTeam(id, dto, principal, request);
   }
 
-  @Put(':id/status')
+  @Post(':id/plan')
   @RequirePermissions('inspections.manage')
-  changeStatus(
+  plan(
     @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: ChangeInspectionVisitStatusDto,
     @CurrentAuth() principal: AuthPrincipal,
     @Req() request: RequestWithContext,
   ) {
-    return this.visits.changeStatus(id, dto, principal, request);
+    return this.lifecycle.plan(id, principal, request);
   }
 
   @Post(':id/start')
@@ -153,7 +156,7 @@ export class InspectionVisitsController {
     @CurrentAuth() principal: AuthPrincipal,
     @Req() request: RequestWithContext,
   ) {
-    return this.visits.start(id, principal, request);
+    return this.lifecycle.start(id, principal, request);
   }
 
   @Post(':id/close')
@@ -164,6 +167,17 @@ export class InspectionVisitsController {
     @CurrentAuth() principal: AuthPrincipal,
     @Req() request: RequestWithContext,
   ) {
-    return this.visits.close(id, dto, principal, request);
+    return this.lifecycle.close(id, dto, principal, request);
+  }
+
+  @Post(':id/cancel')
+  @RequirePermissions('inspections.manage')
+  cancel(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Body() dto: CancelInspectionVisitDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.lifecycle.cancel(id, dto, principal, request);
   }
 }

From 0a8cb8f8e5f56b33f5fce8aec455d119b06b0782 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:20:31 -0300
Subject: [PATCH 052/224] F4: add finding recurrence DTO

---
 .../inspection-findings/dto/set-finding-recurrence.dto.ts   | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 api-v3/src/inspection-findings/dto/set-finding-recurrence.dto.ts

diff --git a/api-v3/src/inspection-findings/dto/set-finding-recurrence.dto.ts b/api-v3/src/inspection-findings/dto/set-finding-recurrence.dto.ts
new file mode 100644
index 0000000..7801e67
--- /dev/null
+++ b/api-v3/src/inspection-findings/dto/set-finding-recurrence.dto.ts
@@ -0,0 +1,6 @@
+import { IsUUID } from 'class-validator';
+
+export class SetFindingRecurrenceDto {
+  @IsUUID('4')
+  recurrenceOfFindingId!: string;
+}

From af6256ce0fcbdf89d492dcadd2b44834aba7923b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:20:56 -0300
Subject: [PATCH 053/224] F4: implement finding recurrence workflow

---
 .../finding-recurrence.service.ts             | 232 ++++++++++++++++++
 1 file changed, 232 insertions(+)
 create mode 100644 api-v3/src/inspection-findings/finding-recurrence.service.ts

diff --git a/api-v3/src/inspection-findings/finding-recurrence.service.ts b/api-v3/src/inspection-findings/finding-recurrence.service.ts
new file mode 100644
index 0000000..a3e7c3e
--- /dev/null
+++ b/api-v3/src/inspection-findings/finding-recurrence.service.ts
@@ -0,0 +1,232 @@
+import {
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { DataSource, EntityManager } from 'typeorm';
+import { administrationAuditContext } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { AuditAction } from '../database/entities';
+import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
+import type { SetFindingRecurrenceDto } from './dto/set-finding-recurrence.dto';
+import { InspectionFindingsService } from './inspection-findings.service';
+
+interface FindingRecurrenceContext {
+  id: string;
+  assetId: string;
+  catalogItemId: string | null;
+  title: string;
+  createdAt: Date;
+  actId: string;
+  actStatus: string;
+  visitId: string;
+  visitStatus: string;
+}
+
+function comparable(value: string): string {
+  return value
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim()
+    .replace(/\s+/g, ' ');
+}
+
+@Injectable()
+export class FindingRecurrenceService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly audit: AuditService,
+    private readonly findings: InspectionFindingsService,
+  ) {}
+
+  async candidates(id: string) {
+    const current = await this.requireFinding(this.dataSource.manager, id, false);
+    const rows = await this.dataSource.query(`
+      SELECT
+        finding.id,finding.code,finding.title,finding.description,finding.status,
+        finding.catalog_item_id AS "catalogItemId",finding.created_at AS "createdAt",
+        act.id AS "actId",act.code AS "actCode",act.occurred_at AS "actOccurredAt",
+        visit.id AS "visitId",visit.code AS "visitCode",visit.status AS "visitStatus"
+      FROM inspection_findings finding
+      JOIN inspection_acts act ON act.id=finding.act_id
+      JOIN inspection_visits visit ON visit.id=act.visit_id
+      WHERE finding.asset_id=$1
+        AND finding.id<>$2
+        AND finding.status<>'VOIDED'
+        AND finding.created_at<$3
+        AND (
+          ($4::uuid IS NOT NULL AND finding.catalog_item_id=$4::uuid)
+          OR ($4::uuid IS NULL AND lower(btrim(finding.title))=lower(btrim($5)))
+        )
+      ORDER BY finding.created_at DESC,finding.id DESC
+      LIMIT 20
+    `, [current.assetId, current.id, current.createdAt, current.catalogItemId, current.title]);
+    return {
+      findingId: current.id,
+      assetId: current.assetId,
+      hasCandidates: rows.length > 0,
+      data: rows,
+    };
+  }
+
+  async link(
+    id: string,
+    dto: SetFindingRecurrenceDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    assertMobileInspector(principal);
+    await this.dataSource.transaction(async (manager) => {
+      const current = await this.requireFinding(manager, id, true);
+      this.assertEditable(current);
+      await this.assertActorAssigned(manager, current.visitId, principal);
+      if (id === dto.recurrenceOfFindingId) {
+        throw new BadRequestException({
+          code: 'FINDING_CANNOT_RECUR_FROM_SELF',
+          message: 'Un Hallazgo no puede ser reincidencia de sí mismo',
+        });
+      }
+      const previous = await this.requireFinding(manager, dto.recurrenceOfFindingId, false);
+      if (previous.assetId !== current.assetId) {
+        throw new ConflictException({
+          code: 'FINDING_RECURRENCE_DIFFERENT_INVENTORY',
+          message: 'La reincidencia debe referir a un Hallazgo anterior del mismo Inventario',
+        });
+      }
+      if (new Date(previous.createdAt).getTime() >= new Date(current.createdAt).getTime()) {
+        throw new ConflictException({
+          code: 'FINDING_RECURRENCE_NOT_PREVIOUS',
+          message: 'El Hallazgo de referencia debe ser anterior al actual',
+        });
+      }
+      const sameCatalog = current.catalogItemId && previous.catalogItemId
+        ? current.catalogItemId === previous.catalogItemId
+        : current.catalogItemId === previous.catalogItemId;
+      const sameTitle = comparable(current.title) === comparable(previous.title);
+      if (!sameCatalog && !sameTitle) {
+        throw new ConflictException({
+          code: 'FINDING_RECURRENCE_NOT_EQUIVALENT',
+          message: 'El antecedente seleccionado no corresponde al mismo tipo de Hallazgo',
+        });
+      }
+
+      const [before] = await manager.query(`
+        SELECT is_recurrence AS "isRecurrence",recurrence_of_finding_id AS "recurrenceOfFindingId"
+        FROM inspection_findings WHERE id=$1 FOR UPDATE
+      `, [id]) as Array<{ isRecurrence: boolean; recurrenceOfFindingId: string | null }>;
+      await manager.query(`
+        UPDATE inspection_findings
+        SET is_recurrence=true,recurrence_of_finding_id=$2,updated_by=$3,updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1
+      `, [id, previous.id, principal.userId]);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_FINDING_RECURRENCE_LINKED,
+        entityType: 'inspection_finding',
+        entityId: id,
+        beforeData: before ?? { isRecurrence: false, recurrenceOfFindingId: null },
+        afterData: {
+          isRecurrence: true,
+          recurrenceOfFindingId: previous.id,
+          recurrenceOfFindingCode: await this.codeForFinding(manager, previous.id),
+        },
+        metadata: { actId: current.actId, visitId: current.visitId },
+      }, manager);
+    });
+    return this.findings.getById(id);
+  }
+
+  async clear(
+    id: string,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    assertMobileInspector(principal);
+    await this.dataSource.transaction(async (manager) => {
+      const current = await this.requireFinding(manager, id, true);
+      this.assertEditable(current);
+      await this.assertActorAssigned(manager, current.visitId, principal);
+      const [before] = await manager.query(`
+        SELECT is_recurrence AS "isRecurrence",recurrence_of_finding_id AS "recurrenceOfFindingId"
+        FROM inspection_findings WHERE id=$1 FOR UPDATE
+      `, [id]) as Array<{ isRecurrence: boolean; recurrenceOfFindingId: string | null }>;
+      if (!before?.isRecurrence && !before?.recurrenceOfFindingId) return;
+      await manager.query(`
+        UPDATE inspection_findings
+        SET is_recurrence=false,recurrence_of_finding_id=NULL,updated_by=$2,updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1
+      `, [id, principal.userId]);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_FINDING_RECURRENCE_CLEARED,
+        entityType: 'inspection_finding',
+        entityId: id,
+        beforeData: before,
+        afterData: { isRecurrence: false, recurrenceOfFindingId: null },
+        metadata: { actId: current.actId, visitId: current.visitId },
+      }, manager);
+    });
+    return this.findings.getById(id);
+  }
+
+  private async requireFinding(
+    manager: EntityManager,
+    id: string,
+    lock: boolean,
+  ): Promise<FindingRecurrenceContext> {
+    const [row] = await manager.query(`
+      SELECT finding.id,finding.asset_id AS "assetId",finding.catalog_item_id AS "catalogItemId",
+        finding.title,finding.created_at AS "createdAt",finding.act_id AS "actId",
+        act.status AS "actStatus",visit.id AS "visitId",visit.status AS "visitStatus"
+      FROM inspection_findings finding
+      JOIN inspection_acts act ON act.id=finding.act_id
+      JOIN inspection_visits visit ON visit.id=act.visit_id
+      WHERE finding.id=$1
+      ${lock ? 'FOR UPDATE OF finding,act,visit' : ''}
+    `, [id]) as FindingRecurrenceContext[];
+    if (!row) {
+      throw new NotFoundException({
+        code: 'INSPECTION_FINDING_NOT_FOUND',
+        message: 'Hallazgo no encontrado',
+      });
+    }
+    return row;
+  }
+
+  private assertEditable(finding: FindingRecurrenceContext): void {
+    if (finding.actStatus !== 'DRAFT' || finding.visitStatus !== 'IN_PROGRESS') {
+      throw new ConflictException({
+        code: 'FINDING_RECURRENCE_IMMUTABLE',
+        message: 'La reincidencia sólo puede definirse mientras el Acta está en BORRADOR y la Inspección en curso',
+      });
+    }
+  }
+
+  private async assertActorAssigned(
+    manager: EntityManager,
+    visitId: string,
+    principal: AuthPrincipal,
+  ): Promise<void> {
+    if (principal.permissions.includes('inspections.manage')) return;
+    const [row] = await manager.query(`
+      SELECT 1 FROM inspection_visit_members
+      WHERE visit_id=$1 AND user_id=$2 AND included=true LIMIT 1
+    `, [visitId, principal.userId]) as unknown[];
+    if (!row) {
+      throw new ForbiddenException({
+        code: 'INSPECTION_NOT_ASSIGNED',
+        message: 'La Inspección no está asignada al usuario actual',
+      });
+    }
+  }
+
+  private async codeForFinding(manager: EntityManager, id: string): Promise<string | null> {
+    const [row] = await manager.query('SELECT code FROM inspection_findings WHERE id=$1', [id]) as Array<{ code: string }>;
+    return row?.code ?? null;
+  }
+}

From 236605a7d7eced26d630559d3e9539ad49e28907 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:21:04 -0300
Subject: [PATCH 054/224] F4: expose finding recurrence endpoints

---
 .../finding-recurrence.controller.ts          | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 api-v3/src/inspection-findings/finding-recurrence.controller.ts

diff --git a/api-v3/src/inspection-findings/finding-recurrence.controller.ts b/api-v3/src/inspection-findings/finding-recurrence.controller.ts
new file mode 100644
index 0000000..c06e773
--- /dev/null
+++ b/api-v3/src/inspection-findings/finding-recurrence.controller.ts
@@ -0,0 +1,47 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Post,
+  Req,
+} from '@nestjs/common';
+import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
+import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { SetFindingRecurrenceDto } from './dto/set-finding-recurrence.dto';
+import { FindingRecurrenceService } from './finding-recurrence.service';
+
+@Controller('inspection-findings')
+export class FindingRecurrenceController {
+  constructor(private readonly recurrence: FindingRecurrenceService) {}
+
+  @Get(':id/recurrence-candidates')
+  @RequirePermissions('inspection_findings.read')
+  candidates(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
+    return this.recurrence.candidates(id);
+  }
+
+  @Post(':id/recurrence')
+  @RequirePermissions('inspection_findings.update')
+  link(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Body() dto: SetFindingRecurrenceDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.recurrence.link(id, dto, principal, request);
+  }
+
+  @Delete(':id/recurrence')
+  @RequirePermissions('inspection_findings.update')
+  clear(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.recurrence.clear(id, principal, request);
+  }
+}

From 8b033dc297e46411fb6d06210bb819531ac89939 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:21:14 -0300
Subject: [PATCH 055/224] F4: wire finding recurrence workflow

---
 api-v3/src/inspection-findings/inspection-findings.module.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/api-v3/src/inspection-findings/inspection-findings.module.ts b/api-v3/src/inspection-findings/inspection-findings.module.ts
index 6ba1fba..de913ca 100644
--- a/api-v3/src/inspection-findings/inspection-findings.module.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.module.ts
@@ -4,6 +4,8 @@ import { FindingCatalogController } from './finding-catalog.controller';
 import { FindingCatalogMergeService } from './finding-catalog-merge.service';
 import { FindingCatalogService } from './finding-catalog.service';
 import { F3FindingCatalogResolverService } from './f3-finding-catalog-resolver.service';
+import { FindingRecurrenceController } from './finding-recurrence.controller';
+import { FindingRecurrenceService } from './finding-recurrence.service';
 import {
   InspectionActFindingsController,
   InspectionFindingsController,
@@ -22,6 +24,7 @@ import { InspectionEvidenceService } from './inspection-evidence.service';
     FindingCatalogController,
     InspectionActFindingsController,
     InspectionFindingsController,
+    FindingRecurrenceController,
     InspectionFindingEvidenceController,
     InspectionFindingCommunicationsController,
     InspectionEvidenceContentController,
@@ -31,6 +34,7 @@ import { InspectionEvidenceService } from './inspection-evidence.service';
     F3FindingCatalogResolverService,
     FindingCatalogMergeService,
     InspectionFindingsService,
+    FindingRecurrenceService,
     InspectionEvidenceService,
   ],
   exports: [
@@ -38,6 +42,7 @@ import { InspectionEvidenceService } from './inspection-evidence.service';
     F3FindingCatalogResolverService,
     FindingCatalogMergeService,
     InspectionFindingsService,
+    FindingRecurrenceService,
   ],
 })
 export class InspectionFindingsModule {}

From c30f167731e61bbf6697c638be19ac295e8c68bf Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:21:46 -0300
Subject: [PATCH 056/224] F4: audit recurrence through finding update ledger

---
 .../src/inspection-findings/finding-recurrence.service.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/api-v3/src/inspection-findings/finding-recurrence.service.ts b/api-v3/src/inspection-findings/finding-recurrence.service.ts
index a3e7c3e..c20f384 100644
--- a/api-v3/src/inspection-findings/finding-recurrence.service.ts
+++ b/api-v3/src/inspection-findings/finding-recurrence.service.ts
@@ -126,7 +126,7 @@ export class FindingRecurrenceService {
       `, [id, previous.id, principal.userId]);
       await this.audit.record({
         ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_FINDING_RECURRENCE_LINKED,
+        action: AuditAction.INSPECTION_FINDING_UPDATED,
         entityType: 'inspection_finding',
         entityId: id,
         beforeData: before ?? { isRecurrence: false, recurrenceOfFindingId: null },
@@ -135,7 +135,7 @@ export class FindingRecurrenceService {
           recurrenceOfFindingId: previous.id,
           recurrenceOfFindingCode: await this.codeForFinding(manager, previous.id),
         },
-        metadata: { actId: current.actId, visitId: current.visitId },
+        metadata: { actId: current.actId, visitId: current.visitId, recurrenceAction: 'LINKED' },
       }, manager);
     });
     return this.findings.getById(id);
@@ -163,12 +163,12 @@ export class FindingRecurrenceService {
       `, [id, principal.userId]);
       await this.audit.record({
         ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_FINDING_RECURRENCE_CLEARED,
+        action: AuditAction.INSPECTION_FINDING_UPDATED,
         entityType: 'inspection_finding',
         entityId: id,
         beforeData: before,
         afterData: { isRecurrence: false, recurrenceOfFindingId: null },
-        metadata: { actId: current.actId, visitId: current.visitId },
+        metadata: { actId: current.actId, visitId: current.visitId, recurrenceAction: 'CLEARED' },
       }, manager);
     });
     return this.findings.getById(id);

From 009f4d10cfed3093473393e32b8610b5b4cb212a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:22:53 -0300
Subject: [PATCH 057/224] F4: keep function history in its temporal ledger

---
 .../src/asset-master/inventory-function.service.ts  | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/api-v3/src/asset-master/inventory-function.service.ts b/api-v3/src/asset-master/inventory-function.service.ts
index 7cdd581..8b5c644 100644
--- a/api-v3/src/asset-master/inventory-function.service.ts
+++ b/api-v3/src/asset-master/inventory-function.service.ts
@@ -8,8 +8,7 @@ import { DataSource, EntityManager } from 'typeorm';
 import { administrationAuditContext } from '../administration/common/administration-audit';
 import { AuditService } from '../audit/audit.service';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { AuditAction, AssetVersionChangeType } from '../database/entities';
-import { AssetHistoryService } from './asset-history.service';
+import { AuditAction } from '../database/entities';
 import type {
   ChangeInventoryFunctionDto,
   CreateInventoryFunctionDto,
@@ -65,7 +64,6 @@ export class InventoryFunctionService {
   constructor(
     private readonly dataSource: DataSource,
     private readonly audit: AuditService,
-    private readonly history: AssetHistoryService,
   ) {}
 
   async list(includeInactive = false): Promise<{ data: InventoryFunctionRow[] }> {
@@ -207,13 +205,6 @@ export class InventoryFunctionService {
       await manager.query(`
         UPDATE assets SET updated_by=$2,updated_at=CURRENT_TIMESTAMP WHERE id=$1
       `, [assetId, principal.userId]);
-      const versionNumber = await this.history.capture(
-        manager,
-        assetId,
-        AssetVersionChangeType.FUNCTION_CHANGED,
-        principal,
-        request,
-      );
       const after = await this.getForAssetWithManager(manager, assetId);
       await this.audit.record({
         ...administrationAuditContext(principal, request),
@@ -236,8 +227,8 @@ export class InventoryFunctionService {
         metadata: {
           inventoryCode: asset.code,
           inventoryName: asset.name,
-          versionNumber,
           temporal: true,
+          historySource: 'inventory_function_assignments',
         },
       }, manager);
       return after;

From d0c55b8b39398ac5d8dc36f89d8f5cf6b3a9285d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:25:53 -0300
Subject: [PATCH 058/224] F4 Android: align Act contracts with lock and seal

---
 .../korexlabs/dhinspeccion/data/MobileActs.kt | 68 +++++++++++++------
 1 file changed, 46 insertions(+), 22 deletions(-)

diff --git a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
index 22bb6eb..a3a40ef 100644
--- a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
+++ b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
@@ -37,6 +37,15 @@ data class MobileActSummary(
     val title: String,
     val summary: String,
     val observations: String? = null,
+    val urgency: String = "NON_URGENT",
+    val deadlineDays: Int? = null,
+    val deadlineDayType: String? = null,
+    val deadlineBasis: String? = null,
+    val deadlineBaseAt: String? = null,
+    val deadlineAt: String? = null,
+    val lockedAt: String? = null,
+    val lockedSha256: String? = null,
+    val sealedAt: String? = null,
     val currentVersion: Int = 0,
     val closedAt: String? = null,
     val closureSha256: String? = null,
@@ -53,6 +62,15 @@ data class MobileActDetail(
     val title: String,
     val summary: String,
     val observations: String? = null,
+    val urgency: String = "NON_URGENT",
+    val deadlineDays: Int? = null,
+    val deadlineDayType: String? = null,
+    val deadlineBasis: String? = null,
+    val deadlineBaseAt: String? = null,
+    val deadlineAt: String? = null,
+    val lockedAt: String? = null,
+    val lockedSha256: String? = null,
+    val sealedAt: String? = null,
     val currentVersion: Int = 0,
     val closedAt: String? = null,
     val closureSha256: String? = null,
@@ -75,6 +93,7 @@ data class MobileActListResponse(
 
 data class CreateMobileActRequest(
     val occurredAt: String,
+    val urgency: String,
     val title: String,
     val summary: String,
     val observations: String? = null,
@@ -113,6 +132,15 @@ data class MobileActClosureHeader(
     val code: String,
     val status: String,
     val visitId: String,
+    val urgency: String = "NON_URGENT",
+    val deadlineDays: Int? = null,
+    val deadlineDayType: String? = null,
+    val deadlineBasis: String? = null,
+    val deadlineBaseAt: String? = null,
+    val deadlineAt: String? = null,
+    val lockedAt: String? = null,
+    val lockedSha256: String? = null,
+    val sealedAt: String? = null,
     val currentVersion: Int = 0,
     val closedAt: String? = null,
     val closureSha256: String? = null,
@@ -169,7 +197,7 @@ data class MobileCompanyOutcomeRequest(
     val reason: String,
 )
 
-data class MobileCloseActRequest(
+data class MobileSealActRequest(
     val clientClosedAt: String = Instant.now().toString(),
     val uploadMode: String = "ONLINE",
 )
@@ -219,14 +247,8 @@ private interface MobileActsApi {
         @Body request: MobileResponsibleRequest,
     ): MobileActClosure
 
-    @POST("inspection-acts/{actId}/ready")
-    suspend fun ready(
-        @Header("Authorization") authorization: String,
-        @Path("actId") actId: String,
-    ): MobileActClosure
-
-    @POST("inspection-acts/{actId}/reopen")
-    suspend fun reopen(
+    @POST("inspection-acts/{actId}/lock")
+    suspend fun lock(
         @Header("Authorization") authorization: String,
         @Path("actId") actId: String,
     ): MobileActClosure
@@ -268,11 +290,11 @@ private interface MobileActsApi {
         @Body request: MobileCompanyOutcomeRequest,
     ): MobileActClosure
 
-    @POST("inspection-acts/{actId}/close")
-    suspend fun closeAct(
+    @POST("inspection-acts/{actId}/seal")
+    suspend fun sealAct(
         @Header("Authorization") authorization: String,
         @Path("actId") actId: String,
-        @Body request: MobileCloseActRequest,
+        @Body request: MobileSealActRequest,
     ): MobileActClosure
 
     @POST("inspection-visits/{visitId}/close")
@@ -305,14 +327,20 @@ class MobileActsRepository(context: Context) {
         api.act("Bearer ${session.accessToken}", actId)
     }
 
-    suspend fun create(visitId: String, assetId: String, visitCode: String): MobileActDetail = authorized { session ->
+    suspend fun create(
+        visitId: String,
+        assetId: String,
+        visitCode: String,
+        urgency: String,
+    ): MobileActDetail = authorized { session ->
         api.createAct(
             "Bearer ${session.accessToken}",
             visitId,
             CreateMobileActRequest(
                 occurredAt = Instant.now().toString(),
+                urgency = urgency,
                 title = "Acta de inspección $visitCode",
-                summary = "Acta de inspección en curso. Los Hallazgos y observaciones se incorporan de forma trazable durante la visita.",
+                summary = "Acta de inspección en curso. Los Hallazgos y observaciones se incorporan de forma trazable durante la inspección.",
                 assetIds = listOf(assetId),
             ),
         )
@@ -335,12 +363,8 @@ class MobileActsRepository(context: Context) {
         api.responsible("Bearer ${session.accessToken}", actId, request)
     }
 
-    suspend fun prepare(actId: String): MobileActClosure = authorized { session ->
-        api.ready("Bearer ${session.accessToken}", actId)
-    }
-
-    suspend fun reopen(actId: String): MobileActClosure = authorized { session ->
-        api.reopen("Bearer ${session.accessToken}", actId)
+    suspend fun lock(actId: String): MobileActClosure = authorized { session ->
+        api.lock("Bearer ${session.accessToken}", actId)
     }
 
     suspend fun signInspector(
@@ -378,8 +402,8 @@ class MobileActsRepository(context: Context) {
         )
     }
 
-    suspend fun closeAct(actId: String): MobileActClosure = authorized { session ->
-        api.closeAct("Bearer ${session.accessToken}", actId, MobileCloseActRequest())
+    suspend fun seal(actId: String): MobileActClosure = authorized { session ->
+        api.sealAct("Bearer ${session.accessToken}", actId, MobileSealActRequest())
     }
 
     suspend fun closeVisit(visitId: String): VisitDetail = authorized { session ->

From d9698f11f0708efd44c055d32bb1088bbcf3dfdf Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:26:55 -0300
Subject: [PATCH 059/224] F4: remove legacy per-Finding company follow-up
 endpoint

---
 .../inspection-findings.controller.ts                | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/api-v3/src/inspection-findings/inspection-findings.controller.ts b/api-v3/src/inspection-findings/inspection-findings.controller.ts
index 1540671..ce33ffe 100644
--- a/api-v3/src/inspection-findings/inspection-findings.controller.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.controller.ts
@@ -15,7 +15,6 @@ import type { AuthPrincipal, RequestWithContext } from '../common/http/request-c
 import { CloseInspectionFindingDto } from './dto/close-inspection-finding.dto';
 import { CreateInspectionFindingDto } from './dto/create-inspection-finding.dto';
 import { ListInspectionFindingsQueryDto } from './dto/list-inspection-findings-query.dto';
-import { UpdateInspectionFindingFollowUpDto } from './dto/update-inspection-finding-follow-up.dto';
 import { UpdateInspectionFindingDto } from './dto/update-inspection-finding.dto';
 import { InspectionFindingsService } from './inspection-findings.service';
 
@@ -84,15 +83,4 @@ export class InspectionFindingsController {
   ) {
     return this.findings.close(id, dto, principal, request);
   }
-
-  @Patch(':id/follow-up')
-  @RequirePermissions('inspection_findings.follow_up')
-  updateFollowUp(
-    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: UpdateInspectionFindingFollowUpDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.findings.updateFollowUp(id, dto, principal, request);
-  }
 }

From 1bed1cae98012c6aded7a7271758c2f1ee429d46 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:28:53 -0300
Subject: [PATCH 060/224] F4 Android: keep branch compiling while UI migrates
 to lock/seal

---
 .../com/korexlabs/dhinspeccion/data/MobileActs.kt   | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
index a3a40ef..3691826 100644
--- a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
+++ b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
@@ -331,7 +331,7 @@ class MobileActsRepository(context: Context) {
         visitId: String,
         assetId: String,
         visitCode: String,
-        urgency: String,
+        urgency: String = "NON_URGENT",
     ): MobileActDetail = authorized { session ->
         api.createAct(
             "Bearer ${session.accessToken}",
@@ -367,6 +367,14 @@ class MobileActsRepository(context: Context) {
         api.lock("Bearer ${session.accessToken}", actId)
     }
 
+    /** Transitional alias used only while the F4 screen migration is in this branch. */
+    suspend fun prepare(actId: String): MobileActClosure = lock(actId)
+
+    /** F4 does not allow reopening an Act once it has been locked. */
+    suspend fun reopen(@Suppress("UNUSED_PARAMETER") actId: String): MobileActClosure {
+        throw IllegalStateException("Un Acta finalizada es inmutable y no puede volver a borrador")
+    }
+
     suspend fun signInspector(
         actId: String,
         png: File,
@@ -406,6 +414,9 @@ class MobileActsRepository(context: Context) {
         api.sealAct("Bearer ${session.accessToken}", actId, MobileSealActRequest())
     }
 
+    /** Transitional alias used only while the F4 screen migration is in this branch. */
+    suspend fun closeAct(actId: String): MobileActClosure = seal(actId)
+
     suspend fun closeVisit(visitId: String): VisitDetail = authorized { session ->
         api.closeVisit("Bearer ${session.accessToken}", visitId, MobileCloseVisitRequest())
     }

From f5ab6ce885358235aebb21f0644f196b066095ae Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:30:43 -0300
Subject: [PATCH 061/224] F4: rebuild Act PDF from locked and sealed snapshot

---
 .../inspection-act-pdf-builder.ts             | 260 +++++++++++++-----
 1 file changed, 192 insertions(+), 68 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-act-pdf-builder.ts b/api-v3/src/inspection-reports/inspection-act-pdf-builder.ts
index 7039abd..e058911 100644
--- a/api-v3/src/inspection-reports/inspection-act-pdf-builder.ts
+++ b/api-v3/src/inspection-reports/inspection-act-pdf-builder.ts
@@ -1,88 +1,212 @@
 import { createHash } from 'node:crypto';
 
-function asRecord(value: unknown): Record<string, unknown> { return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {}; }
-function asArray(value: unknown): Array<Record<string, unknown>> { return Array.isArray(value) ? value.map(asRecord) : []; }
-function text(value: unknown, fallback='-'): string { const out=String(value ?? '').trim(); return out || fallback; }
-function date(value: unknown): string { const d=new Date(String(value ?? '')); return Number.isFinite(d.getTime()) ? d.toLocaleDateString('es-AR') : '-'; }
-function clean(value: string): string { return value.normalize('NFKD').replace(/[\u0300-\u036f]/g,'').replace(/[–—]/g,'-').replace(/[“”]/g,'"').replace(/[‘’]/g,"'").replace(/[^\x20-\xFF]/g,'?'); }
-function escapePdf(value: string): string { return clean(value).replaceAll('\\','\\\\').replaceAll('(','\\(').replaceAll(')','\\)'); }
-function wrap(value: string, max=92): string[] { const words=clean(value).split(/\s+/).filter(Boolean); const out:string[]=[]; let line=''; for(const word of words){ const next=line?`${line} ${word}`:word; if(next.length>max&&line){out.push(line);line=word;}else line=next;} if(line)out.push(line); return out.length?out:['-']; }
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function asArray(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value) ? value.map(asRecord) : [];
+}
+
+function text(value: unknown, fallback = '-'): string {
+  const out = String(value ?? '').trim();
+  return out || fallback;
+}
+
+function date(value: unknown): string {
+  const parsed = new Date(String(value ?? ''));
+  return Number.isFinite(parsed.getTime()) ? parsed.toLocaleDateString('es-AR') : '-';
+}
+
+function clean(value: string): string {
+  return value
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[–—]/g, '-')
+    .replace(/[“”]/g, '"')
+    .replace(/[‘’]/g, "'")
+    .replace(/[^\x20-\xFF]/g, '?');
+}
+
+function escapePdf(value: string): string {
+  return clean(value).replaceAll('\\', '\\\\').replaceAll('(', '\\(').replaceAll(')', '\\)');
+}
+
+function wrap(value: string, max = 92): string[] {
+  const words = clean(value).split(/\s+/).filter(Boolean);
+  const out: string[] = [];
+  let line = '';
+  for (const word of words) {
+    const next = line ? `${line} ${word}` : word;
+    if (next.length > max && line) {
+      out.push(line);
+      line = word;
+    } else {
+      line = next;
+    }
+  }
+  if (line) out.push(line);
+  return out.length ? out : ['-'];
+}
+
+function lockedSnapshot(snapshot: Record<string, unknown>): {
+  locked: Record<string, unknown>;
+  signatures: Array<Record<string, unknown>>;
+  finalSha256: unknown;
+} {
+  const sealed = asRecord(snapshot);
+  const locked = asRecord(sealed.lockedSnapshot ?? sealed.preparedSnapshot);
+  return {
+    locked,
+    signatures: asArray(sealed.signatures),
+    finalSha256: sealed.finalSha256 ?? sealed.lockedSha256 ?? sealed.preparedSha256,
+  };
+}
+
+function urgencyLabel(value: unknown): string {
+  return text(value, '') === 'URGENT' ? 'Urgente' : 'No urgente';
+}
+
+function dayTypeLabel(value: unknown): string {
+  return text(value, '') === 'CALENDAR' ? 'dias corridos' : 'dias habiles';
+}
 
 function lines(snapshot: Record<string, unknown>): string[] {
-  const prepared=asRecord(asRecord(snapshot).preparedSnapshot);
-  const act=asRecord(prepared.act);
-  const visit=asRecord(act.visit);
-  const responsible=asRecord(prepared.responsible);
-  const team=asArray(prepared.team);
-  const assets=asArray(prepared.assets);
-  const findings=asArray(prepared.findings);
-  const signatures=asArray(snapshot.signatures);
-  const companySignature=signatures.find(item=>text(item.signerType,'')==='COMPANY_RESPONSIBLE');
-  const companies=[...new Set(assets.map(x=>text(asRecord(x.operatorCompany).name,'')).filter(Boolean))];
-  const areas=[...new Set(assets.map(x=>text(asRecord(x.operationalArea).name,'')).filter(Boolean))];
-  const inspectors=team.map(x=>`${text(x.firstName,'')} ${text(x.lastName,'')}`.trim()).filter(Boolean);
-  const out:string[]=[
+  const source = lockedSnapshot(snapshot);
+  const locked = source.locked;
+  const act = asRecord(locked.act);
+  const inspection = asRecord(act.inspection ?? asRecord(act).visit);
+  const responsible = asRecord(locked.responsible);
+  const inventories = asArray(locked.inventories ?? locked.assets);
+  const findings = asArray(locked.findings);
+  const signatures = source.signatures;
+  const companySignature = signatures.find((item) => text(item.signerType, '') === 'COMPANY_RESPONSIBLE');
+  const inspectorSignatures = signatures.filter((item) => text(item.signerType, '') === 'INSPECTOR');
+
+  const deadlineText = act.deadlineAt
+    ? `${date(act.deadlineAt)} (${text(act.deadlineDays)} ${dayTypeLabel(act.deadlineDayType)})`
+    : act.deadlineBasis === 'GEDO_DATE'
+      ? `${text(act.deadlineDays)} ${dayTypeLabel(act.deadlineDayType)} desde fecha GEDO`
+      : '-';
+
+  const out: string[] = [
     'ACTA DE INSPECCION',
-    'Documento automatico - diseno institucional pendiente de definicion',
     '',
     `Acta: ${text(act.code)}`,
-    `Inspeccion: ${text(visit.code)}`,
+    `Inspeccion: ${text(inspection.code)}`,
     `Fecha: ${date(act.occurredAt)}`,
-    `Empresa: ${companies.join(' / ') || 'Segun alcance del acta'}`,
-    `Area: ${areas.join(' / ') || 'Segun alcance del acta'}`,
-    `Inspector/es: ${inspectors.join(' / ') || '-'}`,
+    `Urgencia: ${urgencyLabel(act.urgency)}`,
+    `Plazo: ${deadlineText}`,
     `Responsable empresa: ${text(responsible.fullName)}`,
     `Cargo: ${text(responsible.position)}`,
     '',
-    'OBJETIVO', ...wrap(text(visit.objective)), '',
-    'RESUMEN', ...wrap(text(act.summary)), '',
-    'OBSERVACIONES', ...wrap(text(act.observations)), '',
-    'ELEMENTOS INSPECCIONADOS',
+    'RESUMEN',
+    ...wrap(text(act.summary)),
+    '',
+    'OBSERVACIONES',
+    ...wrap(text(act.observations)),
+    '',
+    'INVENTARIO INSPECCIONADO',
   ];
-  if(!assets.length) out.push('-');
-  for(const item of assets) out.push(...wrap(`${text(item.code)} | ${text(item.name)}${text(item.commonName,'') ? ` | ${text(item.commonName,'')}` : ''} | ${text(item.typeName)}`));
-  out.push('', 'HALLAZGOS');
-  if(!findings.length) out.push('Sin hallazgos registrados.');
-  for(const item of findings){ out.push(...wrap(`${text(item.code)} | ${text(item.title)} | Vencimiento: ${date(item.correctionDueOn)}`)); out.push(...wrap(text(item.description))); }
-  out.push('', 'CONSTANCIA DE LA EMPRESA');
-  if(!companySignature) out.push('Firma o constancia pendiente.');
-  else if(text(companySignature.status,'')==='SIGNED'){
-    const manifestation=text(companySignature.companyManifestation,'CONFORMITY');
-    out.push(manifestation==='DISSENT'?'Firma en disidencia':'Firma en conformidad');
-    if(manifestation==='DISSENT') out.push(...wrap(text(companySignature.companyStatement)));
-  } else {
-    out.push(...wrap(`${text(companySignature.status)}: ${text(companySignature.reason)}`));
+
+  if (!inventories.length) out.push('-');
+  for (const item of inventories) {
+    out.push(...wrap(`${text(item.code)} | ${text(item.name)} | ${text(item.typeName ?? item.typeCode)}`));
   }
-  out.push('', 'INTEGRIDAD', `Hash de cierre: ${text(asRecord(snapshot).finalSha256 ?? asRecord(snapshot).preparedSha256)}`);
+
+  out.push('', 'HALLAZGOS');
+  if (!findings.length) out.push('Sin hallazgos registrados.');
+  for (const item of findings) {
+    const recurrence = item.isRecurrence
+      ? ` | REINCIDENCIA${item.recurrenceOfFindingId ? ` de ${text(item.recurrenceOfFindingCode ?? item.recurrenceOfFindingId)}` : ''}`
+      : '';
+    out.push(...wrap(`${text(item.code)} | ${text(item.title)}${recurrence}`));
+    out.push(...wrap(`Descripcion: ${text(item.description)}`));
+    if (item.legalBasis) out.push(...wrap(`Base legal: ${text(item.legalBasis)}`));
+  }
+
+  out.push('', 'FIRMAS Y CONSTANCIAS');
+  if (!inspectorSignatures.length) out.push('Firma de inspector: pendiente.');
+  for (const signature of inspectorSignatures) {
+    out.push(...wrap(`Inspector: ${text(signature.signerName)} | ${text(signature.status)} | ${date(signature.signedAt ?? signature.createdAt)}`));
+  }
+  if (!companySignature) {
+    out.push('Manifestacion de empresa: pendiente.');
+  } else if (text(companySignature.status, '') === 'SIGNED') {
+    const manifestation = text(companySignature.companyManifestation, 'CONFORMITY');
+    out.push(manifestation === 'DISSENT' ? 'Empresa: firma en disidencia' : 'Empresa: firma en conformidad');
+    if (manifestation === 'DISSENT') out.push(...wrap(text(companySignature.companyStatement)));
+  } else {
+    out.push(...wrap(`Empresa: ${text(companySignature.status)} - ${text(companySignature.reason)}`));
+  }
+
+  out.push(
+    '',
+    'INTEGRIDAD',
+    `Hash del Acta sellada: ${text(source.finalSha256)}`,
+    `Hash del contenido bloqueado: ${text(snapshot.lockedSha256 ?? snapshot.preparedSha256)}`,
+  );
   return out;
 }
 
-function objectBuffer(id: number, body: Buffer|string): Buffer { const data=Buffer.isBuffer(body)?body:Buffer.from(body,'latin1'); return Buffer.concat([Buffer.from(`${id} 0 obj\n`,'ascii'),data,Buffer.from('\nendobj\n','ascii')]); }
+function objectBuffer(id: number, body: Buffer | string): Buffer {
+  const data = Buffer.isBuffer(body) ? body : Buffer.from(body, 'latin1');
+  return Buffer.concat([
+    Buffer.from(`${id} 0 obj\n`, 'ascii'),
+    data,
+    Buffer.from('\nendobj\n', 'ascii'),
+  ]);
+}
 
 export function buildInspectionActPdf(snapshot: Record<string, unknown>): { buffer: Buffer; sha256: string } {
-  const all=lines(snapshot);
-  const chunks:Array<string[]>=[];
-  for(let i=0;i<all.length;i+=56) chunks.push(all.slice(i,i+56));
-  if(!chunks.length) chunks.push(['ACTA DE INSPECCION']);
-  const pageCount=chunks.length;
-  const pageIds=Array.from({length:pageCount},(_,i)=>4+i*2);
-  const contentIds=Array.from({length:pageCount},(_,i)=>5+i*2);
-  const objects:Buffer[]=[];
-  objects.push(objectBuffer(1,'<< /Type /Catalog /Pages 2 0 R >>'));
-  objects.push(objectBuffer(2,`<< /Type /Pages /Count ${pageCount} /Kids [${pageIds.map(id=>`${id} 0 R`).join(' ')}] >>`));
-  objects.push(objectBuffer(3,'<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>'));
-  chunks.forEach((chunk,index)=>{
-    const content=chunk.map((line,i)=>`${i===0?'':'T* '}(${escapePdf(line)}) Tj`).join('\n');
-    const stream=Buffer.from(`BT\n/F1 9 Tf\n40 800 Td\n12 TL\n${content}\nET`,'latin1');
-    objects.push(objectBuffer(pageIds[index]!,`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 3 0 R >> >> /Contents ${contentIds[index]} 0 R >>`));
-    objects.push(objectBuffer(contentIds[index]!,Buffer.concat([Buffer.from(`<< /Length ${stream.length} >>\nstream\n`,'ascii'),stream,Buffer.from('\nendstream','ascii')])));
+  const all = lines(snapshot);
+  const chunks: Array<string[]> = [];
+  for (let index = 0; index < all.length; index += 56) chunks.push(all.slice(index, index + 56));
+  if (!chunks.length) chunks.push(['ACTA DE INSPECCION']);
+
+  const pageCount = chunks.length;
+  const pageIds = Array.from({ length: pageCount }, (_, index) => 4 + index * 2);
+  const contentIds = Array.from({ length: pageCount }, (_, index) => 5 + index * 2);
+  const objects: Buffer[] = [];
+  objects.push(objectBuffer(1, '<< /Type /Catalog /Pages 2 0 R >>'));
+  objects.push(objectBuffer(2, `<< /Type /Pages /Count ${pageCount} /Kids [${pageIds.map((id) => `${id} 0 R`).join(' ')}] >>`));
+  objects.push(objectBuffer(3, '<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>'));
+
+  chunks.forEach((chunk, index) => {
+    const content = chunk
+      .map((line, lineIndex) => `${lineIndex === 0 ? '' : 'T* '}(${escapePdf(line)}) Tj`)
+      .join('\n');
+    const stream = Buffer.from(`BT\n/F1 9 Tf\n40 800 Td\n12 TL\n${content}\nET`, 'latin1');
+    objects.push(objectBuffer(
+      pageIds[index]!,
+      `<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 3 0 R >> >> /Contents ${contentIds[index]} 0 R >>`,
+    ));
+    objects.push(objectBuffer(
+      contentIds[index]!,
+      Buffer.concat([
+        Buffer.from(`<< /Length ${stream.length} >>\nstream\n`, 'ascii'),
+        stream,
+        Buffer.from('\nendstream', 'ascii'),
+      ]),
+    ));
   });
-  const header=Buffer.from('%PDF-1.4\n%\xE2\xE3\xCF\xD3\n','binary');
-  const offsets:number[]=[0]; let pos=header.length;
-  for(const obj of objects){ offsets.push(pos); pos+=obj.length; }
-  const xrefOffset=pos;
-  const xref=[`xref\n0 ${objects.length+1}\n`,`0000000000 65535 f \n`,...objects.map((_,i)=>`${String(offsets[i+1]).padStart(10,'0')} 00000 n \n`)].join('');
-  const trailer=`trailer\n<< /Size ${objects.length+1} /Root 1 0 R >>\nstartxref\n${xrefOffset}\n%%EOF\n`;
-  const buffer=Buffer.concat([header,...objects,Buffer.from(xref+trailer,'ascii')]);
-  return { buffer, sha256:createHash('sha256').update(buffer).digest('hex') };
+
+  const header = Buffer.from('%PDF-1.4\n%\xE2\xE3\xCF\xD3\n', 'binary');
+  const offsets: number[] = [0];
+  let position = header.length;
+  for (const object of objects) {
+    offsets.push(position);
+    position += object.length;
+  }
+  const xrefOffset = position;
+  const xref = [
+    `xref\n0 ${objects.length + 1}\n`,
+    '0000000000 65535 f \n',
+    ...objects.map((_, index) => `${String(offsets[index + 1]).padStart(10, '0')} 00000 n \n`),
+  ].join('');
+  const trailer = `trailer\n<< /Size ${objects.length + 1} /Root 1 0 R >>\nstartxref\n${xrefOffset}\n%%EOF\n`;
+  const buffer = Buffer.concat([header, ...objects, Buffer.from(xref + trailer, 'ascii')]);
+  return { buffer, sha256: createHash('sha256').update(buffer).digest('hex') };
 }

From 53702009e3cd024107d0deccaea534136844e0f1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:31:35 -0300
Subject: [PATCH 062/224] F4: rebuild editable INF Word from sealed Act
 snapshot

---
 .../inspection-report-word-builder.ts         | 130 ++++++++++++------
 1 file changed, 89 insertions(+), 41 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-report-word-builder.ts b/api-v3/src/inspection-reports/inspection-report-word-builder.ts
index 387e270..27f30b8 100644
--- a/api-v3/src/inspection-reports/inspection-report-word-builder.ts
+++ b/api-v3/src/inspection-reports/inspection-report-word-builder.ts
@@ -11,6 +11,8 @@ interface ReportWordInput {
   generatedAt: Date;
   frozenSha256: string;
   frozenSnapshot: Record<string, unknown>;
+  executiveSummary?: string | null;
+  reportDescription?: string | null;
 }
 
 const crcTable = (() => {
@@ -56,8 +58,8 @@ function text(value: unknown, fallback = '—'): string {
 }
 
 function isoDate(value: unknown): string {
-  const date = new Date(String(value ?? ''));
-  return Number.isFinite(date.getTime()) ? date.toLocaleDateString('es-AR') : '—';
+  const parsed = new Date(String(value ?? ''));
+  return Number.isFinite(parsed.getTime()) ? parsed.toLocaleDateString('es-AR') : '—';
 }
 
 function paragraph(value: string, style?: 'Title' | 'Heading1' | 'Heading2'): string {
@@ -76,52 +78,96 @@ function table(headers: string[], rows: string[][]): string {
   return `<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/><w:tblBorders><w:top w:val="single" w:sz="4" w:color="B7C9D6"/><w:left w:val="single" w:sz="4" w:color="B7C9D6"/><w:bottom w:val="single" w:sz="4" w:color="B7C9D6"/><w:right w:val="single" w:sz="4" w:color="B7C9D6"/><w:insideH w:val="single" w:sz="4" w:color="D8E1E8"/><w:insideV w:val="single" w:sz="4" w:color="D8E1E8"/></w:tblBorders></w:tblPr>${header}${body}</w:tbl>`;
 }
 
+function f4Snapshot(input: ReportWordInput) {
+  const source = asRecord(input.frozenSnapshot.source);
+  const sealedAct = asRecord(input.frozenSnapshot.sealedAct ?? input.frozenSnapshot.actClosure);
+  const locked = asRecord(sealedAct.lockedSnapshot ?? sealedAct.preparedSnapshot);
+  const act = asRecord(locked.act);
+  const inspection = asRecord(act.inspection ?? act.visit);
+  const responsible = asRecord(locked.responsible);
+  const inventories = asArray(locked.inventories ?? locked.assets);
+  const findings = asArray(locked.findings);
+  const signatures = asArray(sealedAct.signatures);
+  return { source, sealedAct, locked, act, inspection, responsible, inventories, findings, signatures };
+}
+
+function urgency(value: unknown): string {
+  return text(value, '') === 'URGENT' ? 'Urgente' : 'No urgente';
+}
+
+function deadline(act: Record<string, unknown>): string {
+  const type = text(act.deadlineDayType, '') === 'CALENDAR' ? 'días corridos' : 'días hábiles';
+  if (act.deadlineAt) return `${isoDate(act.deadlineAt)} · ${text(act.deadlineDays)} ${type}`;
+  if (text(act.deadlineBasis, '') === 'GEDO_DATE') return `${text(act.deadlineDays)} ${type} desde la fecha de oficialización GEDO`;
+  return '—';
+}
+
 function documentXml(input: ReportWordInput): string {
-  const report = asRecord(input.frozenSnapshot.report);
-  const actClosure = asRecord(input.frozenSnapshot.actClosure);
-  const prepared = asRecord(actClosure.preparedSnapshot);
-  const act = asRecord(prepared.act);
-  const visit = asRecord(act.visit);
-  const responsible = asRecord(prepared.responsible);
-  const team = asArray(prepared.team);
-  const assets = asArray(prepared.assets);
-  const findings = asArray(prepared.findings);
-  const signatures = asArray(actClosure.signatures);
-  const companies = [...new Set(assets.map((item) => text(asRecord(item.operatorCompany).name, '')).filter(Boolean))];
-  const areas = [...new Set(assets.map((item) => text(asRecord(item.operationalArea).name, '')).filter(Boolean))];
-  const inspectorNames = team.map((member) => `${text(member.firstName, '')} ${text(member.lastName, '')}`.trim()).filter(Boolean);
-  const assetRows = assets.map((item) => [text(item.code), text(item.name), text(item.commonName, ''), text(item.typeName)]);
-  const findingRows = findings.map((item) => [text(item.code), text(item.title), text(item.description), item.severity == null ? '—' : `${text(item.severity)}/10`, isoDate(item.correctionDueOn)]);
-  const signatureRows = signatures.map((item) => [text(item.signerType), text(item.signerName), text(item.status), isoDate(item.signedAt ?? item.createdAt)]);
+  const snapshot = f4Snapshot(input);
+  const findingRows = snapshot.findings.map((item) => [
+    text(item.code),
+    text(item.title),
+    text(item.description),
+    item.isRecurrence ? `Sí${item.recurrenceOfFindingCode ? ` · ${text(item.recurrenceOfFindingCode)}` : ''}` : 'No',
+    item.severity == null ? '—' : `${text(item.severity)}/10`,
+  ]);
+  const inventoryRows = snapshot.inventories.map((item) => [
+    text(item.code),
+    text(item.name),
+    text(item.typeName ?? item.typeCode),
+  ]);
+  const signatureRows = snapshot.signatures.map((item) => [
+    text(item.signerType),
+    text(item.signerName),
+    text(item.status),
+    text(item.companyManifestation, ''),
+    isoDate(item.signedAt ?? item.createdAt),
+  ]);
+
+  const executive = input.executiveSummary?.trim()
+    || '[EDITAR] Incorporar aquí el resumen ejecutivo del informe.';
+  const description = input.reportDescription?.trim()
+    || '[EDITAR] Incorporar aquí la descripción técnica, análisis y consideraciones del inspector.';
+
   const body = [
     paragraph('INFORME TÉCNICO DE INSPECCIÓN', 'Title'),
-    paragraph('Borrador automático para revisión del Director de Hidrocarburos', 'Heading2'),
+    paragraph('Documento Word editable para revisión del Inspector antes de su incorporación a GEDO', 'Heading2'),
     labelValue('Informe', input.code),
-    labelValue('Título', input.title),
+    labelValue('Acta fuente', text(snapshot.source.actCode ?? snapshot.act.code)),
+    labelValue('Inspección', text(snapshot.source.inspectionCode ?? snapshot.inspection.code)),
+    labelValue('Fecha de inspección', isoDate(snapshot.act.occurredAt)),
+    labelValue('Urgencia', urgency(snapshot.act.urgency)),
+    labelValue('Plazo', deadline(snapshot.act)),
     labelValue('Fecha de generación', input.generatedAt.toLocaleString('es-AR')),
-    labelValue('Acta', text(report.actCode ?? act.code)),
-    labelValue('Inspección', text(report.visitCode ?? visit.code)),
-    labelValue('Empresa', companies.join(' · ') || 'Según alcance del acta'),
-    labelValue('Área', areas.join(' · ') || 'Según alcance del acta'),
-    labelValue('Inspector/es', inspectorNames.join(' · ') || '—'),
-    labelValue('Responsable de empresa', text(responsible.fullName)),
-    labelValue('Cargo', text(responsible.position)),
-    paragraph('Datos de la visita', 'Heading1'),
-    labelValue('Objetivo', text(visit.objective)),
-    labelValue('Fecha de inspección', isoDate(act.occurredAt)),
-    labelValue('Resumen', text(act.summary)),
-    labelValue('Observaciones', text(act.observations)),
-    paragraph('Elementos inspeccionados', 'Heading1'),
-    assetRows.length ? table(['Código', 'Nombre técnico', 'Nombre habitual', 'Tipo'], assetRows) : paragraph('No se registraron elementos en la instantánea.'),
+    paragraph('Resumen ejecutivo', 'Heading1'),
+    paragraph(executive),
+    paragraph('Descripción / análisis técnico', 'Heading1'),
+    paragraph(description),
+    paragraph('Acta fuente · contenido inmutable', 'Heading1'),
+    paragraph('El bloque siguiente reproduce información proveniente del Acta sellada. Debe conservarse sin alterar su sentido ni sustituir los Hallazgos originales.'),
+    labelValue('Resumen del Acta', text(snapshot.act.summary)),
+    labelValue('Observaciones del Acta', text(snapshot.act.observations)),
+    labelValue('Responsable de empresa', text(snapshot.responsible.fullName)),
+    labelValue('Cargo', text(snapshot.responsible.position)),
+    paragraph('Inventario inspeccionado', 'Heading1'),
+    inventoryRows.length
+      ? table(['Código', 'Nombre', 'Tipo'], inventoryRows)
+      : paragraph('No se registraron elementos de Inventario en el Acta.'),
     paragraph('Hallazgos', 'Heading1'),
-    findingRows.length ? table(['Código', 'Título', 'Descripción', 'Gravedad', 'Vencimiento'], findingRows) : paragraph('No se registraron hallazgos en la instantánea.'),
-    paragraph('Firmas y constancias', 'Heading1'),
-    signatureRows.length ? table(['Tipo', 'Firmante', 'Estado', 'Fecha'], signatureRows) : paragraph('No se registraron firmas en la instantánea.'),
-    paragraph('Integridad documental', 'Heading1'),
-    labelValue('Hash del informe', input.frozenSha256),
-    labelValue('Hash de cierre del acta', text(report.actClosureSha256)),
-    paragraph('El contenido de este archivo fue generado desde la instantánea congelada del acta. El diseño institucional y la firma final del Director se incorporarán en la etapa de revisión correspondiente.'),
+    findingRows.length
+      ? table(['Código', 'Título', 'Descripción', 'Reincidencia', 'Gravedad'], findingRows)
+      : paragraph('El Acta no contiene Hallazgos.'),
+    paragraph('Firmas y manifestaciones', 'Heading1'),
+    signatureRows.length
+      ? table(['Tipo', 'Firmante', 'Estado', 'Manifestación', 'Fecha'], signatureRows)
+      : paragraph('No se registraron firmas en la instantánea sellada.'),
+    paragraph('Integridad de la fuente', 'Heading1'),
+    labelValue('Hash de la fuente del INF', input.frozenSha256),
+    labelValue('Hash del Acta sellada', text(snapshot.source.actClosureSha256 ?? snapshot.sealedAct.finalSha256)),
+    labelValue('Hash del contenido bloqueado', text(snapshot.sealedAct.lockedSha256)),
+    paragraph('Este INF permanece editable mientras está en preparación. La edición del informe no modifica el Acta fuente ni los Hallazgos contenidos en ella. La versión oficial será la que se registre posteriormente en GEDO con su identificador IF y PDF oficial.'),
   ].join('');
+
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${body}<w:sectPr><w:pgSz w:w="11906" w:h="16838"/><w:pgMar w:top="1134" w:right="1134" w:bottom="1134" w:left="1134" w:header="708" w:footer="708" w:gutter="0"/></w:sectPr></w:body></w:document>`;
 }
 
@@ -147,6 +193,7 @@ function buildZip(entries: ZipEntry[]): Buffer {
     local.writeUInt16LE(name.length, 26);
     local.writeUInt16LE(0, 28);
     locals.push(local, name, entry.data);
+
     const central = Buffer.alloc(46);
     central.writeUInt32LE(0x02014b50, 0);
     central.writeUInt16LE(20, 4);
@@ -168,6 +215,7 @@ function buildZip(entries: ZipEntry[]): Buffer {
     centrals.push(central, name);
     offset += local.length + name.length + entry.data.length;
   }
+
   const centralData = Buffer.concat(centrals);
   const end = Buffer.alloc(22);
   end.writeUInt32LE(0x06054b50, 0);

From 0db4567289edd87a69487c6056488f33ad7615d7 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:31:57 -0300
Subject: [PATCH 063/224] F4: include editable INF fields in generated Word

---
 .../inspection-report-word.service.ts         | 124 +++++++++++++-----
 1 file changed, 90 insertions(+), 34 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-report-word.service.ts b/api-v3/src/inspection-reports/inspection-report-word.service.ts
index 4074c81..be0a9dd 100644
--- a/api-v3/src/inspection-reports/inspection-report-word.service.ts
+++ b/api-v3/src/inspection-reports/inspection-report-word.service.ts
@@ -12,6 +12,8 @@ interface WordRow {
   id: string;
   code: string;
   title: string;
+  executiveSummary: string | null;
+  reportDescription: string | null;
   generatedAt: Date;
   frozenSha256: string;
   frozenSnapshot: Record<string, unknown>;
@@ -29,7 +31,8 @@ export class InspectionReportWordService {
   private readonly root: string;
 
   constructor(private readonly dataSource: DataSource, config: ConfigService) {
-    const configured = config.get<string>('INSPECTION_REPORT_WORD_ROOT') ?? '/app/storage/asset-media/inspection-reports-word';
+    const configured = config.get<string>('INSPECTION_REPORT_WORD_ROOT')
+      ?? '/app/storage/asset-media/inspection-reports-word';
     if (!isAbsolute(configured)) throw new Error('INSPECTION_REPORT_WORD_ROOT must be an absolute path');
     this.root = resolve(configured);
     if (this.root === parse(this.root).root) throw new Error('INSPECTION_REPORT_WORD_ROOT cannot be the filesystem root');
@@ -38,7 +41,11 @@ export class InspectionReportWordService {
   async ensure(reportId: string): Promise<void> {
     const row = await this.load(reportId);
     if (row.wordStatus === 'READY' && row.wordStoredName) {
-      try { await this.content(row.id); await this.ensureInitialRevision(row); return; } catch {}
+      try {
+        await this.content(row.id);
+        await this.ensureInitialRevision(row);
+        return;
+      } catch {}
     }
     try {
       const built = buildInspectionReportWord({
@@ -47,6 +54,8 @@ export class InspectionReportWordService {
         generatedAt: new Date(row.generatedAt),
         frozenSha256: row.frozenSha256,
         frozenSnapshot: row.frozenSnapshot,
+        executiveSummary: row.executiveSummary,
+        reportDescription: row.reportDescription,
       });
       await mkdir(this.root, { recursive: true, mode: 0o700 });
       const storedName = `${row.id}.docx`;
@@ -55,32 +64,41 @@ export class InspectionReportWordService {
       await writeFile(filePath, built.buffer, { mode: 0o600 });
       await this.dataSource.query(`
         UPDATE inspection_reports
-        SET word_status = 'READY',
-            word_original_name = $2,
-            word_stored_name = $3,
-            word_mime_type = $4,
-            word_size_bytes = $5,
-            word_sha256 = $6,
-            word_generated_at = CURRENT_TIMESTAMP,
-            word_error = NULL,
-            updated_at = CURRENT_TIMESTAMP
-        WHERE id = $1
+        SET word_status='READY',
+            word_original_name=$2,
+            word_stored_name=$3,
+            word_mime_type=$4,
+            word_size_bytes=$5,
+            word_sha256=$6,
+            word_generated_at=CURRENT_TIMESTAMP,
+            word_error=NULL,
+            updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1
       `, [row.id, originalName, storedName, WORD_MIME, built.buffer.length, built.sha256]);
       await this.ensureInitialRevision(await this.load(row.id));
     } catch (error) {
       const message = error instanceof Error ? error.message.slice(0, 500) : 'Error desconocido';
       await this.dataSource.query(`
         UPDATE inspection_reports
-        SET word_status = 'FAILED', word_error = $2, updated_at = CURRENT_TIMESTAMP
-        WHERE id = $1
+        SET word_status='FAILED',word_error=$2,updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1
       `, [row.id, message]).catch(() => undefined);
     }
   }
 
   async content(reportId: string): Promise<{ filePath: string; originalName: string; mimeType: string }> {
     const row = await this.load(reportId);
-    if (row.wordStatus !== 'READY' || !row.wordStoredName || !row.wordOriginalName || !row.wordSha256 || !row.wordSizeBytes) {
-      throw new NotFoundException({ code: 'INSPECTION_REPORT_WORD_NOT_READY', message: 'El archivo Word del informe todavía no está disponible' });
+    if (
+      row.wordStatus !== 'READY'
+      || !row.wordStoredName
+      || !row.wordOriginalName
+      || !row.wordSha256
+      || !row.wordSizeBytes
+    ) {
+      throw new NotFoundException({
+        code: 'INSPECTION_REPORT_WORD_NOT_READY',
+        message: 'El archivo Word del informe todavía no está disponible',
+      });
     }
     const filePath = resolve(this.root, row.wordStoredName);
     if (!filePath.startsWith(`${this.root}/`)) throw this.storageError();
@@ -89,40 +107,78 @@ export class InspectionReportWordService {
     const buffer = await readFile(filePath);
     const sha256 = createHash('sha256').update(buffer).digest('hex');
     if (sha256 !== row.wordSha256) throw this.storageError();
-    return { filePath, originalName: row.wordOriginalName, mimeType: row.wordMimeType ?? WORD_MIME };
+    return {
+      filePath,
+      originalName: row.wordOriginalName,
+      mimeType: row.wordMimeType ?? WORD_MIME,
+    };
   }
 
-
   private async ensureInitialRevision(row: WordRow): Promise<void> {
-    if (row.wordStatus !== 'READY' || !row.wordOriginalName || !row.wordStoredName || !row.wordMimeType || !row.wordSizeBytes || !row.wordSha256) return;
+    if (
+      row.wordStatus !== 'READY'
+      || !row.wordOriginalName
+      || !row.wordStoredName
+      || !row.wordMimeType
+      || !row.wordSizeBytes
+      || !row.wordSha256
+    ) return;
     await this.dataSource.query(`
       INSERT INTO inspection_report_revisions (
-        report_id, revision_number, source, original_name, stored_name, mime_type,
-        size_bytes, sha256, change_summary, created_by, created_at
-      ) VALUES ($1,1,'AUTO',$2,$3,$4,$5,$6,'Versión automática inicial',$7,COALESCE((SELECT word_generated_at FROM inspection_reports WHERE id=$1),CURRENT_TIMESTAMP))
-      ON CONFLICT (report_id, revision_number) DO NOTHING
-    `, [row.id, row.wordOriginalName, row.wordStoredName, row.wordMimeType, row.wordSizeBytes, row.wordSha256, row.generatedBy]);
+        report_id,revision_number,source,original_name,stored_name,mime_type,
+        size_bytes,sha256,change_summary,created_by,created_at
+      ) VALUES (
+        $1,1,'AUTO',$2,$3,$4,$5,$6,'Versión automática inicial editable',$7,
+        COALESCE((SELECT word_generated_at FROM inspection_reports WHERE id=$1),CURRENT_TIMESTAMP)
+      )
+      ON CONFLICT (report_id,revision_number) DO NOTHING
+    `, [
+      row.id,
+      row.wordOriginalName,
+      row.wordStoredName,
+      row.wordMimeType,
+      row.wordSizeBytes,
+      row.wordSha256,
+      row.generatedBy,
+    ]);
     await this.dataSource.query(`
       UPDATE inspection_reports
-      SET current_revision_number = GREATEST(current_revision_number, 1), updated_at = CURRENT_TIMESTAMP
-      WHERE id = $1
+      SET current_revision_number=GREATEST(current_revision_number,1),updated_at=CURRENT_TIMESTAMP
+      WHERE id=$1
     `, [row.id]);
   }
 
   private async load(reportId: string): Promise<WordRow> {
     const [row] = await this.dataSource.query(`
-      SELECT id, code, title, generated_at AS "generatedAt", frozen_sha256 AS "frozenSha256",
-             frozen_snapshot AS "frozenSnapshot", word_status AS "wordStatus",
-             word_original_name AS "wordOriginalName", word_stored_name AS "wordStoredName",
-             word_mime_type AS "wordMimeType", word_size_bytes::integer AS "wordSizeBytes",
-             word_sha256 AS "wordSha256", generated_by AS "generatedBy"
-      FROM inspection_reports WHERE id = $1
+      SELECT id,code,title,
+             executive_summary AS "executiveSummary",
+             report_description AS "reportDescription",
+             generated_at AS "generatedAt",
+             frozen_sha256 AS "frozenSha256",
+             frozen_snapshot AS "frozenSnapshot",
+             word_status AS "wordStatus",
+             word_original_name AS "wordOriginalName",
+             word_stored_name AS "wordStoredName",
+             word_mime_type AS "wordMimeType",
+             word_size_bytes::integer AS "wordSizeBytes",
+             word_sha256 AS "wordSha256",
+             generated_by AS "generatedBy"
+      FROM inspection_reports
+      WHERE id=$1
     `, [reportId]) as WordRow[];
-    if (!row) throw new NotFoundException({ code: 'INSPECTION_REPORT_NOT_FOUND', message: 'Informe de inspección no encontrado' });
+    if (!row) {
+      throw new NotFoundException({
+        code: 'INSPECTION_REPORT_NOT_FOUND',
+        message: 'Informe de inspección no encontrado',
+      });
+    }
     return row;
   }
 
   private storageError(): InternalServerErrorException {
-    return new InternalServerErrorException({ code: 'INSPECTION_REPORT_WORD_STORAGE_ERROR', message: 'El archivo Word del informe no está disponible o no supera la validación de integridad' });
+    return new InternalServerErrorException({
+      code: 'INSPECTION_REPORT_WORD_STORAGE_ERROR',
+      message: 'El archivo Word del informe no está disponible o no supera la validación de integridad',
+    });
   }
 }

From eeb35da02c213cf33ec9b30e5e7092aee19dcd1d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:32:50 -0300
Subject: [PATCH 064/224] F4: generate Act PDF only from SEALED Acts

---
 .../inspection-act-pdf.service.ts             | 118 ++++++++++++++++--
 1 file changed, 105 insertions(+), 13 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-act-pdf.service.ts b/api-v3/src/inspection-reports/inspection-act-pdf.service.ts
index 056731a..22cef80 100644
--- a/api-v3/src/inspection-reports/inspection-act-pdf.service.ts
+++ b/api-v3/src/inspection-reports/inspection-act-pdf.service.ts
@@ -8,20 +8,112 @@ import { buildInspectionActPdf } from './inspection-act-pdf-builder';
 
 @Injectable()
 export class InspectionActPdfService {
-  private readonly root:string;
-  constructor(private readonly dataSource:DataSource, config:ConfigService){ const configured=config.get<string>('INSPECTION_ACT_PDF_ROOT')??'/app/storage/asset-media/inspection-acts-pdf'; if(!isAbsolute(configured))throw new Error('INSPECTION_ACT_PDF_ROOT must be an absolute path'); this.root=resolve(configured); if(this.root===parse(this.root).root)throw new Error('INSPECTION_ACT_PDF_ROOT cannot be the filesystem root'); }
+  private readonly root: string;
 
-  async ensure(actId:string):Promise<void>{
-    const [row]=await this.dataSource.query(`SELECT a.id,a.code,a.closure_sha256 AS "closureSha256",c.final_snapshot AS "finalSnapshot",p.status,p.stored_name AS "storedName" FROM inspection_acts a JOIN inspection_act_closures c ON c.act_id=a.id LEFT JOIN inspection_act_pdf_artifacts p ON p.act_id=a.id WHERE a.id=$1 AND a.status='CLOSED'`,[actId]) as Array<{id:string;code:string;closureSha256:string;finalSnapshot:Record<string,unknown>;status:string|null;storedName:string|null}>;
-    if(!row)throw new NotFoundException({code:'INSPECTION_ACT_NOT_CLOSED',message:'El acta cerrada no está disponible'});
-    if(row.status==='READY'&&row.storedName){ try{ await this.content(actId); return; }catch{} }
-    await this.dataSource.query(`INSERT INTO inspection_act_pdf_artifacts (act_id,status) VALUES ($1,'PENDING') ON CONFLICT (act_id) DO UPDATE SET status='PENDING',error=NULL,updated_at=CURRENT_TIMESTAMP`,[actId]);
-    try{
-      const snapshot={...row.finalSnapshot,finalSha256:row.closureSha256}; const built=buildInspectionActPdf(snapshot); await mkdir(this.root,{recursive:true,mode:0o700}); const storedName=`${actId}.pdf`; const originalName=`${row.code}.pdf`; const filePath=resolve(this.root,storedName); await writeFile(filePath,built.buffer,{mode:0o600});
-      await this.dataSource.query(`UPDATE inspection_act_pdf_artifacts SET status='READY',original_name=$2,stored_name=$3,mime_type='application/pdf',size_bytes=$4,sha256=$5,generated_at=CURRENT_TIMESTAMP,error=NULL,updated_at=CURRENT_TIMESTAMP WHERE act_id=$1`,[actId,originalName,storedName,built.buffer.length,built.sha256]);
-    }catch(error){ const message=error instanceof Error?error.message.slice(0,500):'Error desconocido'; await this.dataSource.query(`UPDATE inspection_act_pdf_artifacts SET status='FAILED',error=$2,updated_at=CURRENT_TIMESTAMP WHERE act_id=$1`,[actId,message]).catch(()=>undefined); }
+  constructor(private readonly dataSource: DataSource, config: ConfigService) {
+    const configured = config.get<string>('INSPECTION_ACT_PDF_ROOT')
+      ?? '/app/storage/asset-media/inspection-acts-pdf';
+    if (!isAbsolute(configured)) throw new Error('INSPECTION_ACT_PDF_ROOT must be an absolute path');
+    this.root = resolve(configured);
+    if (this.root === parse(this.root).root) throw new Error('INSPECTION_ACT_PDF_ROOT cannot be the filesystem root');
   }
 
-  async content(actId:string):Promise<{buffer:Buffer;originalName:string;mimeType:string}>{ const [row]=await this.dataSource.query(`SELECT original_name AS "originalName",stored_name AS "storedName",mime_type AS "mimeType",size_bytes::integer AS "sizeBytes",sha256 FROM inspection_act_pdf_artifacts WHERE act_id=$1 AND status='READY'`,[actId]) as Array<{originalName:string;storedName:string;mimeType:string;sizeBytes:number;sha256:string}>; if(!row)throw new NotFoundException({code:'INSPECTION_ACT_PDF_NOT_READY',message:'El PDF del acta todavía no está disponible'}); const filePath=resolve(this.root,row.storedName); if(!filePath.startsWith(`${this.root}/`))throw this.storageError(); const st=await stat(filePath).catch(()=>null); if(!st?.isFile()||st.size!==row.sizeBytes)throw this.storageError(); const buffer=await readFile(filePath); if(createHash('sha256').update(buffer).digest('hex')!==row.sha256)throw this.storageError(); return {buffer,originalName:row.originalName,mimeType:row.mimeType}; }
-  private storageError(){return new InternalServerErrorException({code:'INSPECTION_ACT_PDF_STORAGE_ERROR',message:'El PDF del acta no está disponible o no supera la validación de integridad'});}
+  async ensure(actId: string): Promise<void> {
+    const [row] = await this.dataSource.query(`
+      SELECT
+        act.id,
+        act.code,
+        act.closure_sha256 AS "closureSha256",
+        closure.final_snapshot AS "finalSnapshot",
+        artifact.status,
+        artifact.stored_name AS "storedName"
+      FROM inspection_acts act
+      JOIN inspection_act_closures closure ON closure.act_id=act.id
+      LEFT JOIN inspection_act_pdf_artifacts artifact ON artifact.act_id=act.id
+      WHERE act.id=$1 AND act.status='SEALED'
+    `, [actId]) as Array<{
+      id: string;
+      code: string;
+      closureSha256: string;
+      finalSnapshot: Record<string, unknown>;
+      status: string | null;
+      storedName: string | null;
+    }>;
+    if (!row) {
+      throw new NotFoundException({
+        code: 'INSPECTION_ACT_NOT_SEALED',
+        message: 'El PDF sólo puede generarse desde un Acta SELLADA',
+      });
+    }
+    if (row.status === 'READY' && row.storedName) {
+      try {
+        await this.content(actId);
+        return;
+      } catch {}
+    }
+    await this.dataSource.query(`
+      INSERT INTO inspection_act_pdf_artifacts(act_id,status)
+      VALUES($1,'PENDING')
+      ON CONFLICT (act_id) DO UPDATE SET
+        status='PENDING',error=NULL,updated_at=CURRENT_TIMESTAMP
+    `, [actId]);
+    try {
+      const snapshot = { ...row.finalSnapshot, finalSha256: row.closureSha256 };
+      const built = buildInspectionActPdf(snapshot);
+      await mkdir(this.root, { recursive: true, mode: 0o700 });
+      const storedName = `${actId}.pdf`;
+      const originalName = `${row.code}.pdf`;
+      const filePath = resolve(this.root, storedName);
+      await writeFile(filePath, built.buffer, { mode: 0o600 });
+      await this.dataSource.query(`
+        UPDATE inspection_act_pdf_artifacts
+        SET status='READY',original_name=$2,stored_name=$3,mime_type='application/pdf',
+            size_bytes=$4,sha256=$5,generated_at=CURRENT_TIMESTAMP,error=NULL,
+            updated_at=CURRENT_TIMESTAMP
+        WHERE act_id=$1
+      `, [actId, originalName, storedName, built.buffer.length, built.sha256]);
+    } catch (error) {
+      const message = error instanceof Error ? error.message.slice(0, 500) : 'Error desconocido';
+      await this.dataSource.query(`
+        UPDATE inspection_act_pdf_artifacts
+        SET status='FAILED',error=$2,updated_at=CURRENT_TIMESTAMP
+        WHERE act_id=$1
+      `, [actId, message]).catch(() => undefined);
+    }
+  }
+
+  async content(actId: string): Promise<{ buffer: Buffer; originalName: string; mimeType: string }> {
+    const [row] = await this.dataSource.query(`
+      SELECT original_name AS "originalName",stored_name AS "storedName",
+             mime_type AS "mimeType",size_bytes::integer AS "sizeBytes",sha256
+      FROM inspection_act_pdf_artifacts
+      WHERE act_id=$1 AND status='READY'
+    `, [actId]) as Array<{
+      originalName: string;
+      storedName: string;
+      mimeType: string;
+      sizeBytes: number;
+      sha256: string;
+    }>;
+    if (!row) {
+      throw new NotFoundException({
+        code: 'INSPECTION_ACT_PDF_NOT_READY',
+        message: 'El PDF del Acta todavía no está disponible',
+      });
+    }
+    const filePath = resolve(this.root, row.storedName);
+    if (!filePath.startsWith(`${this.root}/`)) throw this.storageError();
+    const fileStat = await stat(filePath).catch(() => null);
+    if (!fileStat?.isFile() || fileStat.size !== row.sizeBytes) throw this.storageError();
+    const buffer = await readFile(filePath);
+    if (createHash('sha256').update(buffer).digest('hex') !== row.sha256) throw this.storageError();
+    return { buffer, originalName: row.originalName, mimeType: row.mimeType };
+  }
+
+  private storageError(): InternalServerErrorException {
+    return new InternalServerErrorException({
+      code: 'INSPECTION_ACT_PDF_STORAGE_ERROR',
+      message: 'El PDF del Acta no está disponible o no supera la validación de integridad',
+    });
+  }
 }

From ef084dd8990a223e7ed45231bd3e97b045622727 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:33:53 -0300
Subject: [PATCH 065/224] F4 Android: align ViewModel with urgency lock and
 seal

---
 .../korexlabs/dhinspeccion/MainViewModel.kt   | 49 +++++++++++--------
 1 file changed, 29 insertions(+), 20 deletions(-)

diff --git a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/MainViewModel.kt b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/MainViewModel.kt
index 5124554..96a0be7 100644
--- a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/MainViewModel.kt
+++ b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/MainViewModel.kt
@@ -151,11 +151,15 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
         }
     }
 
-    fun createActForSelectedInventory() {
+    fun createActForSelectedInventory(urgency: String = "NON_URGENT") {
         val currentVisit = visit ?: return
         val asset = selectedFieldAsset?.asset
         if (currentVisit.status != "IN_PROGRESS") {
-            error = "La inspección debe estar en curso para crear un Acta."
+            error = "La Inspección debe estar en curso para crear un Acta."
+            return
+        }
+        if (urgency !in setOf("URGENT", "NON_URGENT")) {
+            error = "Elegí si el Acta es urgente o no urgente."
             return
         }
         if (asset == null) {
@@ -163,15 +167,21 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
             return
         }
         if (acts.any { it.status == "DRAFT" }) {
-            error = "Ya existe un Acta en borrador. Cerrala o cancelala antes de crear la siguiente."
+            error = "Ya existe un Acta en borrador. Bloqueala o cancelala antes de crear la siguiente."
             return
         }
         launchBusy {
-            val created = actsRepository.create(currentVisit.id, asset.id, currentVisit.code)
+            val created = actsRepository.create(
+                currentVisit.id,
+                asset.id,
+                currentVisit.code,
+                urgency,
+            )
             selectedAct = created
             actClosure = actsRepository.closure(created.id)
             loadActsInternal(currentVisit.id, selectDraft = false)
-            notice = "${created.code} creada. Los Hallazgos nuevos quedarán vinculados explícitamente a esta Acta."
+            val urgencyLabel = if (urgency == "URGENT") "urgente" else "no urgente"
+            notice = "${created.code} creada como $urgencyLabel. Los Hallazgos nuevos quedarán vinculados explícitamente a esta Acta."
             if (selectedFieldAsset?.capture?.readyForFinding == true) {
                 loadFindingOptionsInternal(currentVisit.id, asset.id, created.id)
             }
@@ -196,7 +206,7 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
         val visitId = visit?.id ?: return
         launchBusy {
             selectedFieldAsset = repository.selectFieldAsset(visitId, item.id)
-            notice = "Inventario agregado a la inspección."
+            notice = "Inventario agregado a la Inspección."
             inventory = repository.fieldInventory(visitId, null, null).data
             val draft = selectedDraftAct()
             if (selectedFieldAsset?.capture?.readyForFinding == true && draft != null) {
@@ -222,7 +232,7 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
     ) {
         val visitId = visit?.id ?: return
         if (visit?.status != "IN_PROGRESS") {
-            error = "La inspección debe estar en curso para dar de alta Inventario."
+            error = "La Inspección debe estar en curso para dar de alta Inventario."
             return
         }
         if (type.familyRequired && familyId == null) {
@@ -449,26 +459,21 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
                     absenceReason = reason.trim(),
                 ),
             )
-            notice = "Ausencia del responsable registrada."
+            notice = "Ausencia del responsable registrada. La manifestación de empresa quedará pendiente y deberá resolverse antes de sellar el Acta."
         }
     }
 
     fun prepareSelectedAct() {
         val actId = selectedAct?.id ?: return
         launchBusy {
-            actClosure = actsRepository.prepare(actId)
+            actClosure = actsRepository.lock(actId)
             refreshSelectedActInternal(actId)
-            notice = "Acta preparada. Su contenido quedó congelado para las firmas."
+            notice = "Acta bloqueada. Su contenido quedó inmutable; ahora deben resolverse las firmas y manifestaciones."
         }
     }
 
     fun reopenSelectedAct() {
-        val actId = selectedAct?.id ?: return
-        launchBusy {
-            actClosure = actsRepository.reopen(actId)
-            refreshSelectedActInternal(actId)
-            notice = "Acta reabierta. Podés corregirla antes de volver a preparar."
-        }
+        error = "Un Acta bloqueada es inmutable y no puede volver a borrador."
     }
 
     fun signSelectedActAsInspector(
@@ -507,13 +512,17 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
 
     fun recordCompanyOutcome(status: String, reason: String) {
         val actId = selectedAct?.id ?: return
+        if (status != "REFUSED") {
+            error = "La ausencia no resuelve la manifestación de la empresa. Registrá una firma o una negativa."
+            return
+        }
         if (reason.trim().length < 10) {
             error = "Indicá un motivo de al menos 10 caracteres."
             return
         }
         launchBusy {
             actClosure = actsRepository.companyOutcome(actId, status, reason)
-            notice = if (status == "ABSENT") "Ausencia de empresa asentada." else "Negativa a firmar asentada."
+            notice = "Negativa a firmar asentada."
         }
     }
 
@@ -521,11 +530,11 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
         val currentVisit = visit ?: return
         val actId = selectedAct?.id ?: return
         launchBusy {
-            actClosure = actsRepository.closeAct(actId)
+            actClosure = actsRepository.seal(actId)
             refreshSelectedActInternal(actId)
             loadActsInternal(currentVisit.id, selectDraft = false)
             clearFindingState()
-            notice = "${selectedAct?.code ?: "Acta"} cerrada e inmutable. Podés crear otra Acta o finalizar la inspección."
+            notice = "${selectedAct?.code ?: "Acta"} SELLADA e inmutable. Podés crear otra Acta o continuar hacia el cierre de la Inspección."
         }
     }
 
@@ -534,7 +543,7 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
         launchBusy {
             visit = actsRepository.closeVisit(visitId)
             loadVisitsInternal()
-            notice = "Inspección cerrada. Las Actas y documentos quedan disponibles para oficina."
+            notice = "Inspección cerrada. Todas sus Actas quedaron SELLADAS y disponibles para el circuito de oficina."
         }
     }
 

From 73c69c7a626272f9f995cb58e387831e14c9fdae Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:34:45 -0300
Subject: [PATCH 066/224] F4 Android: redesign Act screen for DRAFT LOCKED
 SEALED

---
 .../dhinspeccion/ui/MobileActsScreen.kt       | 118 ++++++++++--------
 1 file changed, 68 insertions(+), 50 deletions(-)

diff --git a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/ui/MobileActsScreen.kt b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/ui/MobileActsScreen.kt
index 6d2a2dc..2f2d3d9 100644
--- a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/ui/MobileActsScreen.kt
+++ b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/ui/MobileActsScreen.kt
@@ -60,6 +60,7 @@ fun MobileActsScreen(
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
 
+    var newActUrgency by rememberSaveable(visit.id) { mutableStateOf("NON_URGENT") }
     var attendance by rememberSaveable(selected?.id) {
         mutableStateOf(closure?.responsible?.attendanceStatus ?: "PRESENT")
     }
@@ -129,19 +130,20 @@ fun MobileActsScreen(
 
         Card(Modifier.fillMaxWidth()) {
             Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                Text("Actas de esta inspección", fontWeight = FontWeight.Bold)
+                Text("Actas de esta Inspección", fontWeight = FontWeight.Bold)
                 if (model.acts.isEmpty()) {
                     Text("Todavía no hay Actas. La primera se inicia sobre una Instalación/Subinstalación seleccionada.")
                 }
                 model.acts.forEach { act ->
                     val active = selected?.id == act.id
+                    val urgency = if (act.urgency == "URGENT") "URGENTE" else "No urgente"
                     OutlinedButton(
                         onClick = { model.selectAct(act.id) },
                         modifier = Modifier.fillMaxWidth(),
                     ) {
                         Text(
                             (if (active) "✓ " else "") +
-                                "${act.code} · ${actStatusLabel(act.status)} · ${act.findingCount} Hallazgo${if (act.findingCount == 1) "" else "s"}",
+                                "${act.code} · ${actStatusLabel(act.status)} · $urgency · ${act.findingCount} Hallazgo${if (act.findingCount == 1) "" else "s"}",
                         )
                     }
                 }
@@ -156,12 +158,31 @@ fun MobileActsScreen(
             ) {
                 Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
                     Text("Nueva Acta", fontWeight = FontWeight.Bold)
-                    if (model.acts.any { it.status == "READY" }) {
+                    if (model.acts.any { it.status == "LOCKED" }) {
                         Text(
-                            "Puede existir una nueva Acta en borrador aunque haya Actas preparadas pendientes de firma de empresa. Sólo se permite un borrador a la vez.",
+                            "Podés abrir una nueva Acta aunque otra esté BLOQUEADA esperando firmas. Sólo se permite un borrador a la vez.",
                             style = MaterialTheme.typography.bodySmall,
                         )
                     }
+                    Text("Urgencia del Acta", fontWeight = FontWeight.Bold)
+                    Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                        AssistChip(
+                            onClick = { newActUrgency = "NON_URGENT" },
+                            label = { Text(if (newActUrgency == "NON_URGENT") "✓ No urgente" else "No urgente") },
+                        )
+                        AssistChip(
+                            onClick = { newActUrgency = "URGENT" },
+                            label = { Text(if (newActUrgency == "URGENT") "✓ Urgente" else "Urgente") },
+                        )
+                    }
+                    Text(
+                        if (newActUrgency == "URGENT") {
+                            "El plazo urgente se computará desde el Acta según la política institucional vigente al bloquearla."
+                        } else {
+                            "El plazo no urgente se computará desde la oficialización GEDO según la política institucional vigente al bloquearla."
+                        },
+                        style = MaterialTheme.typography.bodySmall,
+                    )
                     val selectedInventory = model.selectedFieldAsset?.asset
                     if (selectedInventory == null) {
                         Text("Primero elegí una Instalación o Subinstalación desde Inventario de campo. Ese registro será el primer elemento del Acta.")
@@ -171,7 +192,7 @@ fun MobileActsScreen(
                     } else {
                         Text("Inventario inicial: ${selectedInventory.name} · ${selectedInventory.code}")
                         Button(
-                            onClick = { model.createActForSelectedInventory() },
+                            onClick = { model.createActForSelectedInventory(newActUrgency) },
                             enabled = !model.busy,
                             modifier = Modifier.fillMaxWidth(),
                         ) { Text("Crear nueva Acta") }
@@ -186,9 +207,14 @@ fun MobileActsScreen(
                 Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(5.dp)) {
                     Text(selected.code, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
                     Text(actStatusLabel(selected.status))
+                    Text(if (selected.urgency == "URGENT") "Urgente" else "No urgente")
                     Text("${selected.findingCount} Hallazgo${if (selected.findingCount == 1) "" else "s"} · ${selected.assetCount} elemento${if (selected.assetCount == 1) "" else "s"} de Inventario")
-                    Text(selected.summary, style = MaterialTheme.typography.bodySmall)
-                    selected.closureSha256?.let { Text("Hash final: $it", style = MaterialTheme.typography.bodySmall) }
+                    selected.deadlineAt?.let { Text("Vencimiento calculado: $it", style = MaterialTheme.typography.bodySmall) }
+                    if (selected.deadlineAt == null && selected.deadlineBasis == "GEDO_DATE") {
+                        Text("Vencimiento pendiente de fecha GEDO.", style = MaterialTheme.typography.bodySmall)
+                    }
+                    selected.lockedSha256?.let { Text("Hash bloqueado: $it", style = MaterialTheme.typography.bodySmall) }
+                    selected.closureSha256?.let { Text("Hash sellado: $it", style = MaterialTheme.typography.bodySmall) }
                 }
             }
 
@@ -234,31 +260,28 @@ fun MobileActsScreen(
 
                     HorizontalDivider()
                     Text("2. Hallazgos / verificaciones", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
-                    Text("Los Hallazgos se cargan desde Inventario y quedan vinculados a ${selected.code} de forma explícita. Un Acta de verificación puede prepararse sin Hallazgos nuevos si la verificación ya fue registrada.")
+                    Text("Los Hallazgos se cargan desde Inventario y quedan vinculados explícitamente a ${selected.code}. El Acta también puede finalizar sin Hallazgos cuando corresponde dejar constancia de una inspección o verificación sin nuevos incumplimientos.")
                     Button(onClick = onGoInventory, modifier = Modifier.fillMaxWidth()) { Text("Ir a Inventario / Hallazgos") }
 
                     HorizontalDivider()
-                    Text("3. Preparar Acta", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
-                    Text("Al preparar, el contenido se congela y se calcula su hash. El servidor exige al menos un Hallazgo o una verificación registrada.")
+                    Text("3. Finalizar contenido", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
+                    Text("Al BLOQUEAR el Acta, el contenido y los Hallazgos quedan inmutables. Esta acción no se puede deshacer.")
                     Button(
                         onClick = { model.prepareSelectedAct() },
                         enabled = !model.busy && closure?.responsible != null,
                         modifier = Modifier.fillMaxWidth(),
-                    ) { Text("Preparar Acta para firmas") }
+                    ) { Text("Finalizar y BLOQUEAR Acta") }
                 }
 
-                "READY" -> {
+                "LOCKED" -> {
                     val signatures = closure?.signatures.orEmpty()
                     val inspectorSigned = signatures.any { it.signerType == "INSPECTOR" && it.status == "SIGNED" }
                     val companyOutcome = signatures.firstOrNull { it.signerType == "COMPANY_RESPONSIBLE" }
+                    val companyResolved = companyOutcome?.status == "SIGNED" || companyOutcome?.status == "REFUSED"
 
-                    Text("Acta preparada", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
-                    closure?.closure?.preparedSha256?.let { Text("Hash preparado: $it", style = MaterialTheme.typography.bodySmall) }
-                    if (signatures.isEmpty()) {
-                        OutlinedButton(onClick = { model.reopenSelectedAct() }, enabled = !model.busy, modifier = Modifier.fillMaxWidth()) {
-                            Text("Volver a borrador")
-                        }
-                    }
+                    Text("Acta BLOQUEADA", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
+                    Text("El contenido ya es inmutable. Sólo resta resolver firmas y manifestaciones para poder SELLARLA.")
+                    closure?.closure?.preparedSha256?.let { Text("Hash bloqueado: $it", style = MaterialTheme.typography.bodySmall) }
 
                     HorizontalDivider()
                     Text("Firma del inspector", fontWeight = FontWeight.Bold)
@@ -274,29 +297,21 @@ fun MobileActsScreen(
                     }
 
                     HorizontalDivider()
-                    Text("Recepción de la empresa", fontWeight = FontWeight.Bold)
-                    if (companyOutcome != null) {
+                    Text("Manifestación de la empresa", fontWeight = FontWeight.Bold)
+                    if (companyOutcome != null && companyResolved) {
                         val detail = when (companyOutcome.status) {
-                            "SIGNED" -> if (companyOutcome.companyManifestation == "DISSENT") "Firma en disidencia" else "Firma registrada"
+                            "SIGNED" -> if (companyOutcome.companyManifestation == "DISSENT") "Firma en disidencia" else "Firma en conformidad"
                             "REFUSED" -> "Negativa a firmar"
-                            "ABSENT" -> "Responsable ausente"
                             else -> companyOutcome.status
                         }
                         Text("✓ $detail", color = MaterialTheme.colorScheme.primary)
                         companyOutcome.reason?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
                         companyOutcome.companyStatement?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
                     } else if (closure?.responsible?.attendanceStatus == "ABSENT") {
-                        Text("El responsable fue registrado como ausente.")
-                        Button(
-                            onClick = {
-                                model.recordCompanyOutcome(
-                                    "ABSENT",
-                                    closure.responsible.absenceReason ?: "Responsable de empresa ausente durante la inspección",
-                                )
-                            },
-                            enabled = !model.busy && inspectorSigned,
-                            modifier = Modifier.fillMaxWidth(),
-                        ) { Text("Asentar ausencia en el Acta") }
+                        Text(
+                            "El responsable fue registrado como ausente. La ausencia NO resuelve la manifestación: deberá obtenerse firma o negativa posteriormente antes de SELLAR el Acta.",
+                            style = MaterialTheme.typography.bodyMedium,
+                        )
                     } else {
                         Text(closure?.consents?.company.orEmpty(), style = MaterialTheme.typography.bodySmall)
                         Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
@@ -333,28 +348,28 @@ fun MobileActsScreen(
                     }
 
                     HorizontalDivider()
-                    if (inspectorSigned && companyOutcome != null) {
+                    if (inspectorSigned && companyResolved) {
                         Button(
                             onClick = { model.closeSelectedAct() },
                             enabled = !model.busy,
                             modifier = Modifier.fillMaxWidth(),
-                        ) { Text("Cerrar Acta definitivamente") }
-                    } else if (inspectorSigned) {
+                        ) { Text("SELLAR Acta definitivamente") }
+                    } else {
                         Text(
-                            "La inspección puede finalizar con la firma de empresa pendiente; el Acta permanecerá preparada hasta registrar firma, negativa o ausencia.",
+                            "Esta Acta bloquea el cierre de la Inspección hasta tener firma de inspector y firma o negativa válida de la empresa.",
                             style = MaterialTheme.typography.bodySmall,
                         )
                     }
                 }
 
-                "CLOSED" -> {
+                "SEALED" -> {
                     Card(
                         Modifier.fillMaxWidth(),
                         colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primaryContainer),
                     ) {
                         Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(5.dp)) {
-                            Text("Acta cerrada e inmutable", fontWeight = FontWeight.Bold)
-                            Text("El PDF, informe Word y entregas documentales se generan desde este cierre.")
+                            Text("Acta SELLADA e inmutable", fontWeight = FontWeight.Bold)
+                            Text("Desde este sellado se genera el PDF del Acta y el INF Word editable para el Inspector.")
                             closure?.closure?.finalSha256?.let { Text("SHA-256: $it", style = MaterialTheme.typography.bodySmall) }
                         }
                     }
@@ -366,16 +381,19 @@ fun MobileActsScreen(
 
         if (visit.status == "IN_PROGRESS" && model.acts.isNotEmpty()) {
             HorizontalDivider()
-            val drafts = model.acts.count { it.status == "DRAFT" }
-            Text("Finalizar inspección", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
-            Text(
-                "No puede quedar ninguna Acta en borrador. Al cerrar, el servidor verifica que cada Acta preparada tenga firma de inspector; si falta alguna, indicará cuál debe completarse.",
-            )
+            val activeActs = model.acts.filter { it.status != "CANCELLED" }
+            val pendingActs = activeActs.filter { it.status != "SEALED" }
+            Text("Finalizar Inspección", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
+            if (pendingActs.isEmpty()) {
+                Text("Todas las Actas están SELLADAS. La Inspección ya puede cerrarse.")
+            } else {
+                Text("No puede cerrarse todavía. Falta SELLAR: ${pendingActs.joinToString { it.code }}")
+            }
             Button(
                 onClick = { model.closeInspection() },
-                enabled = !model.busy && drafts == 0,
+                enabled = !model.busy && activeActs.isNotEmpty() && pendingActs.isEmpty(),
                 modifier = Modifier.fillMaxWidth(),
-            ) { Text("Cerrar inspección y salir de la empresa") }
+            ) { Text("Cerrar Inspección y salir de la empresa") }
         }
     }
 }
@@ -397,8 +415,8 @@ private fun F32ActMessage(model: MainViewModel) {
 
 private fun actStatusLabel(status: String): String = when (status) {
     "DRAFT" -> "Borrador"
-    "READY" -> "Preparada para firmas"
-    "CLOSED" -> "Cerrada"
+    "LOCKED" -> "BLOQUEADA"
+    "SEALED" -> "SELLADA"
     "CANCELLED" -> "Cancelada"
     else -> status
 }

From 161f4a9252ef5e6de838633254f6cf1ddbbb52d0 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:36:15 -0300
Subject: [PATCH 067/224] F4: add secure remote company signature invitations

---
 ...0000200000-f4-company-signature-invites.ts | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 api-v3/src/database/migrations/1790000200000-f4-company-signature-invites.ts

diff --git a/api-v3/src/database/migrations/1790000200000-f4-company-signature-invites.ts b/api-v3/src/database/migrations/1790000200000-f4-company-signature-invites.ts
new file mode 100644
index 0000000..99c2c4e
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000200000-f4-company-signature-invites.ts
@@ -0,0 +1,51 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class F4CompanySignatureInvites1790000200000 implements MigrationInterface {
+  name = 'F4CompanySignatureInvites1790000200000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE inspection_act_company_signature_invites (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        act_id uuid NOT NULL,
+        token_sha256 char(64) NOT NULL UNIQUE,
+        recipient_email varchar(320) NOT NULL,
+        recipient_name varchar(200),
+        recipient_document_type varchar(20),
+        recipient_document_number varchar(40),
+        recipient_position varchar(200),
+        status varchar(20) NOT NULL DEFAULT 'PENDING',
+        expires_at timestamptz NOT NULL,
+        sent_at timestamptz,
+        used_at timestamptz,
+        revoked_at timestamptz,
+        created_by uuid NOT NULL,
+        revoked_by uuid,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT fk_company_signature_invite_act FOREIGN KEY (act_id)
+          REFERENCES inspection_acts(id) ON DELETE CASCADE,
+        CONSTRAINT fk_company_signature_invite_created_by FOREIGN KEY (created_by)
+          REFERENCES users(id) ON DELETE RESTRICT,
+        CONSTRAINT fk_company_signature_invite_revoked_by FOREIGN KEY (revoked_by)
+          REFERENCES users(id) ON DELETE SET NULL,
+        CONSTRAINT chk_company_signature_invite_status CHECK (
+          status IN ('PENDING','USED','REVOKED','EXPIRED')
+        )
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX idx_company_signature_invites_act_created
+      ON inspection_act_company_signature_invites(act_id,created_at DESC)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX idx_company_signature_invites_pending_expiry
+      ON inspection_act_company_signature_invites(status,expires_at)
+      WHERE status='PENDING'
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query('DROP TABLE IF EXISTS inspection_act_company_signature_invites');
+  }
+}

From badb79be5b041f2647bc0f227b7e2606db1a41a4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:37:13 -0300
Subject: [PATCH 068/224] F4: add remote company signature invitation DTOs

---
 .../dto/company-signature-invite.dto.ts       | 101 ++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 api-v3/src/inspection-closing/dto/company-signature-invite.dto.ts

diff --git a/api-v3/src/inspection-closing/dto/company-signature-invite.dto.ts b/api-v3/src/inspection-closing/dto/company-signature-invite.dto.ts
new file mode 100644
index 0000000..110b4e1
--- /dev/null
+++ b/api-v3/src/inspection-closing/dto/company-signature-invite.dto.ts
@@ -0,0 +1,101 @@
+import { Transform, Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsEmail,
+  IsIn,
+  IsInt,
+  IsOptional,
+  IsString,
+  Max,
+  MaxLength,
+  Min,
+  MinLength,
+  ValidateIf,
+} from 'class-validator';
+
+export class CreateCompanySignatureInviteDto {
+  @IsOptional()
+  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : undefined)
+  @IsEmail()
+  @MaxLength(320)
+  recipientEmail?: string;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(30)
+  expiresInDays?: number;
+}
+
+export class PublicCompanySignatureDto {
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(200)
+  fullName!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim().toUpperCase() : value)
+  @IsString()
+  @IsIn(['DNI', 'CUIL', 'PASSPORT', 'OTHER'])
+  documentType!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(3)
+  @MaxLength(40)
+  documentNumber!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(200)
+  position!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim().toUpperCase() : value)
+  @IsString()
+  @IsIn(['CONFORMITY', 'DISSENT'])
+  manifestation!: 'CONFORMITY' | 'DISSENT';
+
+  @ValidateIf((value: PublicCompanySignatureDto) => value.manifestation === 'DISSENT')
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(10)
+  @MaxLength(8000)
+  statement?: string;
+
+  @Transform(({ value }) => value === true || value === 'true')
+  @IsBoolean()
+  consentAccepted!: boolean;
+}
+
+export class PublicCompanyRefusalDto {
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(200)
+  fullName!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim().toUpperCase() : value)
+  @IsString()
+  @IsIn(['DNI', 'CUIL', 'PASSPORT', 'OTHER'])
+  documentType!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(3)
+  @MaxLength(40)
+  documentNumber!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(2)
+  @MaxLength(200)
+  position!: string;
+
+  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
+  @IsString()
+  @MinLength(10)
+  @MaxLength(8000)
+  reason!: string;
+}

From a178f64763bde81e1496d303bdad147545c3855b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:38:23 -0300
Subject: [PATCH 069/224] F4: implement secure remote company signature
 workflow

---
 .../company-signature-invite.service.ts       | 624 ++++++++++++++++++
 1 file changed, 624 insertions(+)
 create mode 100644 api-v3/src/inspection-closing/company-signature-invite.service.ts

diff --git a/api-v3/src/inspection-closing/company-signature-invite.service.ts b/api-v3/src/inspection-closing/company-signature-invite.service.ts
new file mode 100644
index 0000000..16bc4ab
--- /dev/null
+++ b/api-v3/src/inspection-closing/company-signature-invite.service.ts
@@ -0,0 +1,624 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import { isAbsolute, parse, resolve } from 'node:path';
+import {
+  ConflictException,
+  GoneException,
+  Injectable,
+  InternalServerErrorException,
+  NotFoundException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DataSource, EntityManager } from 'typeorm';
+import { administrationAuditContext } from '../administration/common/administration-audit';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import {
+  AuditSource,
+  InspectionActSignatureSource,
+  InspectionActSignatureStatus,
+  InspectionActSignerType,
+  InspectionCompanySignatureManifestation,
+} from '../database/entities';
+import { SmtpDeliveryService } from '../inspection-reports/smtp-delivery.service';
+import { sha256CanonicalJson } from './canonical-json';
+import type {
+  CreateCompanySignatureInviteDto,
+  PublicCompanyRefusalDto,
+  PublicCompanySignatureDto,
+} from './dto/company-signature-invite.dto';
+import {
+  inspectInspectionSignatureFile,
+  type UploadedInspectionSignatureFile,
+} from './inspection-signature-file';
+
+const REMOTE_CONSENT_VERSION = 'F4-1';
+const REMOTE_COMPANY_CONSENT = 'Declaro haber leído o recibido explicación del contenido del Acta y que esta firma se incorpora como constancia de recepción, sin implicar aceptación de los Hallazgos.';
+
+interface InviteContext {
+  id: string;
+  actId: string;
+  tokenSha256: string;
+  recipientEmail: string;
+  recipientName: string | null;
+  recipientDocumentType: string | null;
+  recipientDocumentNumber: string | null;
+  recipientPosition: string | null;
+  status: 'PENDING' | 'USED' | 'REVOKED' | 'EXPIRED';
+  expiresAt: Date;
+  sentAt: Date | null;
+  usedAt: Date | null;
+  createdBy: string;
+  actCode: string;
+  actStatus: string;
+  lockedSha256: string | null;
+  lockedAt: Date | null;
+  inspectionCode: string;
+  lockedSnapshot: Record<string, unknown> | null;
+}
+
+@Injectable()
+export class CompanySignatureInviteService {
+  private readonly signatureRoot: string;
+
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly audit: AuditService,
+    private readonly smtp: SmtpDeliveryService,
+    private readonly config: ConfigService,
+  ) {
+    const configured = config.get<string>('INSPECTION_SIGNATURE_ROOT')
+      ?? '/app/storage/asset-media/inspection-signatures';
+    if (!isAbsolute(configured)) throw new Error('INSPECTION_SIGNATURE_ROOT must be an absolute path');
+    this.signatureRoot = resolve(configured);
+    if (this.signatureRoot === parse(this.signatureRoot).root) {
+      throw new Error('INSPECTION_SIGNATURE_ROOT cannot be the filesystem root');
+    }
+  }
+
+  async create(
+    actId: string,
+    dto: CreateCompanySignatureInviteDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    const token = randomBytes(32).toString('base64url');
+    const tokenSha256 = this.hashToken(token);
+    const expiresAt = new Date(Date.now() + (dto.expiresInDays ?? 7) * 24 * 60 * 60 * 1000);
+
+    const created = await this.dataSource.transaction(async (manager) => {
+      await this.assertActorAssigned(manager, actId, principal);
+      const [context] = await manager.query(`
+        SELECT
+          act.id,
+          act.code,
+          act.status,
+          act.locked_sha256 AS "lockedSha256",
+          responsible.full_name AS "fullName",
+          responsible.document_type AS "documentType",
+          responsible.document_number AS "documentNumber",
+          responsible.position,
+          responsible.email AS "responsibleEmail",
+          visit.code AS "inspectionCode",
+          (
+            SELECT profile.notification_email
+            FROM inspection_act_assets link
+            JOIN assets inventory ON inventory.id=link.asset_id
+            JOIN asset_types inventory_type ON inventory_type.id=inventory.asset_type_id
+            JOIN assets company ON company.id=COALESCE(
+              inventory.operator_company_id,
+              CASE WHEN inventory_type.operational_role='COMPANY' THEN inventory.id END
+            )
+            LEFT JOIN organization_profiles profile ON profile.asset_id=company.id
+            WHERE link.act_id=act.id AND link.included=true
+              AND profile.notification_email IS NOT NULL
+            ORDER BY company.id
+            LIMIT 1
+          ) AS "companyEmail"
+        FROM inspection_acts act
+        JOIN inspection_visits visit ON visit.id=act.visit_id
+        LEFT JOIN inspection_act_responsibles responsible ON responsible.act_id=act.id
+        WHERE act.id=$1
+        FOR UPDATE OF act
+      `, [actId]) as Array<{
+        id: string;
+        code: string;
+        status: string;
+        lockedSha256: string | null;
+        fullName: string | null;
+        documentType: string | null;
+        documentNumber: string | null;
+        position: string | null;
+        responsibleEmail: string | null;
+        inspectionCode: string;
+        companyEmail: string | null;
+      }>;
+      if (!context) {
+        throw new NotFoundException({ code: 'INSPECTION_ACT_NOT_FOUND', message: 'Acta no encontrada' });
+      }
+      if (context.status !== 'LOCKED' || !context.lockedSha256) {
+        throw new ConflictException({
+          code: 'COMPANY_SIGNATURE_INVITE_ACT_NOT_LOCKED',
+          message: 'La invitación de firma sólo puede emitirse para un Acta BLOQUEADA',
+        });
+      }
+      if (await this.hasCompanyOutcome(manager, actId)) {
+        throw new ConflictException({
+          code: 'COMPANY_SIGNATURE_ALREADY_RESOLVED',
+          message: 'La manifestación de la empresa ya fue registrada',
+        });
+      }
+      const recipientEmail = dto.recipientEmail
+        ?? context.responsibleEmail?.toLowerCase()
+        ?? context.companyEmail?.toLowerCase()
+        ?? null;
+      if (!recipientEmail) {
+        throw new ConflictException({
+          code: 'COMPANY_SIGNATURE_EMAIL_REQUIRED',
+          message: 'No hay email de responsable ni email institucional de empresa; indicá un destinatario',
+        });
+      }
+
+      await manager.query(`
+        UPDATE inspection_act_company_signature_invites
+        SET status='REVOKED',revoked_at=CURRENT_TIMESTAMP,revoked_by=$2,updated_at=CURRENT_TIMESTAMP
+        WHERE act_id=$1 AND status='PENDING'
+      `, [actId, principal.userId]);
+
+      const [invite] = await manager.query(`
+        INSERT INTO inspection_act_company_signature_invites(
+          act_id,token_sha256,recipient_email,recipient_name,recipient_document_type,
+          recipient_document_number,recipient_position,expires_at,created_by
+        ) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9)
+        RETURNING id,act_id AS "actId",recipient_email AS "recipientEmail",
+          expires_at AS "expiresAt",created_at AS "createdAt"
+      `, [
+        actId,
+        tokenSha256,
+        recipientEmail,
+        context.fullName,
+        context.documentType,
+        context.documentNumber,
+        context.position,
+        expiresAt,
+        principal.userId,
+      ]) as Array<{
+        id: string;
+        actId: string;
+        recipientEmail: string;
+        expiresAt: Date;
+        createdAt: Date;
+      }>;
+
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: 'INSPECTION_ACT_COMPANY_SIGNATURE_INVITE_CREATED',
+        entityType: 'inspection_act_company_signature_invite',
+        entityId: invite.id,
+        afterData: {
+          actId,
+          actCode: context.code,
+          recipientEmail,
+          expiresAt,
+        },
+        metadata: { tokenStoredAsHashOnly: true },
+      }, manager);
+      return { ...invite, actCode: context.code, inspectionCode: context.inspectionCode };
+    });
+
+    const publicBase = this.config.get<string>('COMPANY_SIGNATURE_PUBLIC_BASE_URL')?.trim().replace(/\/$/, '') ?? null;
+    const publicUrl = publicBase ? `${publicBase}?token=${encodeURIComponent(token)}` : null;
+    let emailSent = false;
+    let deliveryError: string | null = null;
+
+    if (!publicUrl) {
+      deliveryError = 'COMPANY_SIGNATURE_PUBLIC_BASE_URL no configurada';
+    } else if (!(await this.smtp.configured())) {
+      deliveryError = 'SMTP no configurado';
+    } else {
+      const body = [
+        `Se solicita revisar y manifestarse sobre el Acta ${created.actCode}.`,
+        `Inspección: ${created.inspectionCode}.`,
+        '',
+        'El enlace permite firmar en conformidad, firmar en disidencia o registrar una negativa a firmar.',
+        'El contenido del Acta está bloqueado y no puede modificarse desde este enlace.',
+        '',
+        `Enlace seguro: ${publicUrl}`,
+        `Válido hasta: ${new Date(created.expiresAt).toLocaleString('es-AR')}`,
+      ].join('\n');
+      try {
+        await this.smtp.send({
+          to: created.recipientEmail,
+          subject: `DH Inspección · Firma de ${created.actCode}`,
+          text: body,
+          attachment: {
+            filename: `${created.actCode}-instrucciones.txt`,
+            mimeType: 'text/plain',
+            content: Buffer.from(body, 'utf8'),
+          },
+        });
+        emailSent = true;
+        await this.dataSource.query(`
+          UPDATE inspection_act_company_signature_invites
+          SET sent_at=CURRENT_TIMESTAMP,updated_at=CURRENT_TIMESTAMP
+          WHERE id=$1
+        `, [created.id]);
+      } catch (error) {
+        deliveryError = error instanceof Error ? error.message.slice(0, 500) : 'No se pudo enviar el email';
+      }
+    }
+
+    return {
+      id: created.id,
+      actId: created.actId,
+      actCode: created.actCode,
+      recipientEmail: created.recipientEmail,
+      expiresAt: created.expiresAt,
+      emailSent,
+      deliveryError,
+      publicUrl,
+    };
+  }
+
+  async view(token: string) {
+    const invite = await this.resolveToken(this.dataSource.manager, token, false);
+    const locked = invite.lockedSnapshot ?? {};
+    const act = this.record(locked.act);
+    const inventories = this.records(locked.inventories);
+    const findings = this.records(locked.findings).map((finding) => ({
+      id: finding.id,
+      code: finding.code,
+      title: finding.title,
+      description: finding.description,
+      legalBasis: finding.legalBasis ?? null,
+      severity: finding.severity ?? null,
+      isRecurrence: finding.isRecurrence === true,
+      recurrenceOfFindingId: finding.recurrenceOfFindingId ?? null,
+    }));
+    return {
+      invitation: {
+        id: invite.id,
+        recipientEmail: invite.recipientEmail,
+        expiresAt: invite.expiresAt,
+      },
+      act: {
+        code: invite.actCode,
+        inspectionCode: invite.inspectionCode,
+        lockedAt: invite.lockedAt,
+        lockedSha256: invite.lockedSha256,
+        urgency: act.urgency ?? null,
+        summary: act.summary ?? null,
+        observations: act.observations ?? null,
+      },
+      responsibleDefaults: {
+        fullName: invite.recipientName,
+        documentType: invite.recipientDocumentType,
+        documentNumber: invite.recipientDocumentNumber,
+        position: invite.recipientPosition,
+      },
+      inventories: inventories.map((inventory) => ({
+        id: inventory.id,
+        code: inventory.code,
+        name: inventory.name,
+        typeName: inventory.typeName ?? inventory.typeCode ?? null,
+      })),
+      findings,
+      consent: REMOTE_COMPANY_CONSENT,
+      allowedActions: ['SIGN_CONFORMITY', 'SIGN_DISSENT', 'REFUSE'],
+    };
+  }
+
+  async sign(
+    token: string,
+    dto: PublicCompanySignatureDto,
+    file: UploadedInspectionSignatureFile | undefined,
+    request: RequestWithContext,
+  ) {
+    if (!dto.consentAccepted) {
+      throw new ConflictException({
+        code: 'COMPANY_SIGNATURE_CONSENT_REQUIRED',
+        message: 'Debe aceptarse la constancia antes de firmar',
+      });
+    }
+    const inspected = inspectInspectionSignatureFile(file);
+    const id = randomUUID();
+    const storedName = `${id}.png`;
+    const filePath = resolve(this.signatureRoot, storedName);
+    const imageSha256 = createHash('sha256').update(file!.buffer).digest('hex');
+    await mkdir(this.signatureRoot, { recursive: true, mode: 0o700 });
+    await writeFile(filePath, file!.buffer, { flag: 'wx', mode: 0o600 });
+
+    try {
+      const result = await this.dataSource.transaction(async (manager) => {
+        const invite = await this.resolveToken(manager, token, true);
+        await this.assertNoCompanyOutcome(manager, invite.actId);
+        const signedAt = new Date();
+        const manifestation = dto.manifestation === 'DISSENT'
+          ? InspectionCompanySignatureManifestation.DISSENT
+          : InspectionCompanySignatureManifestation.CONFORMITY;
+        const statement = manifestation === InspectionCompanySignatureManifestation.DISSENT
+          ? dto.statement?.trim() ?? null
+          : null;
+        const payload = {
+          invitationId: invite.id,
+          actId: invite.actId,
+          lockedSha256: invite.lockedSha256,
+          signerType: InspectionActSignerType.COMPANY_RESPONSIBLE,
+          signerName: dto.fullName,
+          documentType: dto.documentType,
+          documentNumber: dto.documentNumber,
+          position: dto.position,
+          status: InspectionActSignatureStatus.SIGNED,
+          companyManifestation: manifestation,
+          companyStatement: statement,
+          imageSha256,
+          consentText: REMOTE_COMPANY_CONSENT,
+          consentVersion: REMOTE_CONSENT_VERSION,
+          signedAt: signedAt.toISOString(),
+          source: InspectionActSignatureSource.WEB,
+        };
+        const signaturePayloadSha256 = sha256CanonicalJson(payload);
+        await manager.query(`
+          INSERT INTO inspection_act_signatures(
+            id,act_id,signer_type,signer_user_id,signer_name,document_type,document_number,
+            position,status,company_manifestation,company_statement,original_name,stored_name,
+            mime_type,size_bytes,image_sha256,consent_text,consent_version,consent_accepted_at,
+            signed_at,device_label,source,prepared_sha256,signature_payload_sha256,uploaded_by,created_at
+          ) VALUES(
+            $1,$2,'COMPANY_RESPONSIBLE',NULL,$3,$4,$5,$6,'SIGNED',$7,$8,$9,$10,$11,$12,$13,
+            $14,$15,$16,$16,'Firma remota por enlace seguro','WEB',$17,$18,$19,$16
+          )
+        `, [
+          id,
+          invite.actId,
+          dto.fullName,
+          dto.documentType,
+          dto.documentNumber,
+          dto.position,
+          manifestation,
+          statement,
+          inspected.originalName,
+          storedName,
+          inspected.mimeType,
+          file!.buffer.length,
+          imageSha256,
+          REMOTE_COMPANY_CONSENT,
+          REMOTE_CONSENT_VERSION,
+          signedAt,
+          invite.lockedSha256,
+          signaturePayloadSha256,
+          invite.createdBy,
+        ]);
+        await manager.query(`
+          UPDATE inspection_act_company_signature_invites
+          SET status='USED',used_at=$2,updated_at=$2
+          WHERE id=$1
+        `, [invite.id, signedAt]);
+        await this.audit.record({
+          action: 'INSPECTION_ACT_COMPANY_REMOTE_SIGNATURE_RECORDED',
+          entityType: 'inspection_act_signature',
+          entityId: id,
+          source: AuditSource.WEB,
+          actorUserId: null,
+          actorUsername: null,
+          requestId: request.requestId,
+          ip: request.ip ?? null,
+          userAgent: request.get('user-agent') ?? null,
+          afterData: payload,
+          metadata: {
+            invitationId: invite.id,
+            recipientEmail: invite.recipientEmail,
+            immutable: true,
+            signaturePayloadSha256,
+          },
+        }, manager);
+        return { actCode: invite.actCode, signatureId: id, manifestation };
+      });
+      return { ok: true, ...result };
+    } catch (error) {
+      await unlink(filePath).catch(() => undefined);
+      throw error;
+    }
+  }
+
+  async refuse(
+    token: string,
+    dto: PublicCompanyRefusalDto,
+    request: RequestWithContext,
+  ) {
+    return this.dataSource.transaction(async (manager) => {
+      const invite = await this.resolveToken(manager, token, true);
+      await this.assertNoCompanyOutcome(manager, invite.actId);
+      const createdAt = new Date();
+      const id = randomUUID();
+      const payload = {
+        invitationId: invite.id,
+        actId: invite.actId,
+        lockedSha256: invite.lockedSha256,
+        signerType: InspectionActSignerType.COMPANY_RESPONSIBLE,
+        signerName: dto.fullName,
+        documentType: dto.documentType,
+        documentNumber: dto.documentNumber,
+        position: dto.position,
+        status: InspectionActSignatureStatus.REFUSED,
+        reason: dto.reason,
+        source: InspectionActSignatureSource.WEB,
+        createdAt: createdAt.toISOString(),
+      };
+      const signaturePayloadSha256 = sha256CanonicalJson(payload);
+      await manager.query(`
+        INSERT INTO inspection_act_signatures(
+          id,act_id,signer_type,signer_user_id,signer_name,document_type,document_number,
+          position,status,reason,source,prepared_sha256,signature_payload_sha256,uploaded_by,created_at
+        ) VALUES($1,$2,'COMPANY_RESPONSIBLE',NULL,$3,$4,$5,$6,'REFUSED',$7,'WEB',$8,$9,$10,$11)
+      `, [
+        id,
+        invite.actId,
+        dto.fullName,
+        dto.documentType,
+        dto.documentNumber,
+        dto.position,
+        dto.reason,
+        invite.lockedSha256,
+        signaturePayloadSha256,
+        invite.createdBy,
+        createdAt,
+      ]);
+      await manager.query(`
+        UPDATE inspection_act_company_signature_invites
+        SET status='USED',used_at=$2,updated_at=$2
+        WHERE id=$1
+      `, [invite.id, createdAt]);
+      await this.audit.record({
+        action: 'INSPECTION_ACT_COMPANY_REMOTE_REFUSAL_RECORDED',
+        entityType: 'inspection_act_signature',
+        entityId: id,
+        source: AuditSource.WEB,
+        actorUserId: null,
+        actorUsername: null,
+        requestId: request.requestId,
+        ip: request.ip ?? null,
+        userAgent: request.get('user-agent') ?? null,
+        afterData: payload,
+        metadata: {
+          invitationId: invite.id,
+          recipientEmail: invite.recipientEmail,
+          immutable: true,
+          signaturePayloadSha256,
+        },
+      }, manager);
+      return { ok: true, actCode: invite.actCode, refusalId: id };
+    });
+  }
+
+  private async resolveToken(
+    manager: EntityManager,
+    token: string,
+    lock: boolean,
+  ): Promise<InviteContext> {
+    if (!/^[A-Za-z0-9_-]{40,120}$/.test(token)) throw this.invalidInvite();
+    const tokenSha256 = this.hashToken(token);
+    const [invite] = await manager.query(`
+      SELECT
+        invite.id,
+        invite.act_id AS "actId",
+        invite.token_sha256 AS "tokenSha256",
+        invite.recipient_email AS "recipientEmail",
+        invite.recipient_name AS "recipientName",
+        invite.recipient_document_type AS "recipientDocumentType",
+        invite.recipient_document_number AS "recipientDocumentNumber",
+        invite.recipient_position AS "recipientPosition",
+        invite.status,
+        invite.expires_at AS "expiresAt",
+        invite.sent_at AS "sentAt",
+        invite.used_at AS "usedAt",
+        invite.created_by AS "createdBy",
+        act.code AS "actCode",
+        act.status AS "actStatus",
+        act.locked_sha256 AS "lockedSha256",
+        act.locked_at AS "lockedAt",
+        visit.code AS "inspectionCode",
+        closure.prepared_snapshot AS "lockedSnapshot"
+      FROM inspection_act_company_signature_invites invite
+      JOIN inspection_acts act ON act.id=invite.act_id
+      JOIN inspection_visits visit ON visit.id=act.visit_id
+      JOIN inspection_act_closures closure ON closure.act_id=act.id
+      WHERE invite.token_sha256=$1
+      ${lock ? 'FOR UPDATE OF invite,act' : ''}
+    `, [tokenSha256]) as InviteContext[];
+    if (!invite) throw this.invalidInvite();
+    if (invite.status !== 'PENDING') {
+      throw new GoneException({
+        code: 'COMPANY_SIGNATURE_INVITE_NOT_ACTIVE',
+        message: invite.status === 'USED'
+          ? 'Este enlace ya fue utilizado'
+          : 'Este enlace ya no está vigente',
+      });
+    }
+    if (new Date(invite.expiresAt).getTime() <= Date.now()) {
+      await manager.query(`
+        UPDATE inspection_act_company_signature_invites
+        SET status='EXPIRED',updated_at=CURRENT_TIMESTAMP
+        WHERE id=$1 AND status='PENDING'
+      `, [invite.id]);
+      throw new GoneException({
+        code: 'COMPANY_SIGNATURE_INVITE_EXPIRED',
+        message: 'El enlace de firma venció. Solicitá una nueva invitación.',
+      });
+    }
+    if (invite.actStatus !== 'LOCKED' || !invite.lockedSha256 || !invite.lockedSnapshot) {
+      throw new ConflictException({
+        code: 'COMPANY_SIGNATURE_ACT_NOT_AVAILABLE',
+        message: 'El Acta ya no está disponible para manifestación remota',
+      });
+    }
+    return invite;
+  }
+
+  private async assertActorAssigned(
+    manager: EntityManager,
+    actId: string,
+    principal: AuthPrincipal,
+  ): Promise<void> {
+    if (principal.permissions.includes('inspections.manage')) return;
+    const [row] = await manager.query(`
+      SELECT 1
+      FROM inspection_acts act
+      JOIN inspection_visit_members member ON member.visit_id=act.visit_id
+      WHERE act.id=$1 AND member.user_id=$2 AND member.included=true
+      LIMIT 1
+    `, [actId, principal.userId]) as unknown[];
+    if (!row) {
+      throw new ConflictException({
+        code: 'COMPANY_SIGNATURE_INVITE_NOT_ASSIGNED',
+        message: 'Sólo un Inspector asignado puede emitir la invitación',
+      });
+    }
+  }
+
+  private async assertNoCompanyOutcome(manager: EntityManager, actId: string): Promise<void> {
+    if (await this.hasCompanyOutcome(manager, actId)) {
+      throw new ConflictException({
+        code: 'COMPANY_SIGNATURE_ALREADY_RESOLVED',
+        message: 'La manifestación de la empresa ya fue registrada',
+      });
+    }
+  }
+
+  private async hasCompanyOutcome(manager: EntityManager, actId: string): Promise<boolean> {
+    const rows = await manager.query(`
+      SELECT 1 FROM inspection_act_signatures
+      WHERE act_id=$1 AND signer_type='COMPANY_RESPONSIBLE'
+      LIMIT 1
+    `, [actId]) as unknown[];
+    return rows.length > 0;
+  }
+
+  private hashToken(token: string): string {
+    return createHash('sha256').update(token, 'utf8').digest('hex');
+  }
+
+  private invalidInvite(): NotFoundException {
+    return new NotFoundException({
+      code: 'COMPANY_SIGNATURE_INVITE_NOT_FOUND',
+      message: 'El enlace de firma no es válido',
+    });
+  }
+
+  private record(value: unknown): Record<string, unknown> {
+    return value && typeof value === 'object' && !Array.isArray(value)
+      ? value as Record<string, unknown>
+      : {};
+  }
+
+  private records(value: unknown): Array<Record<string, unknown>> {
+    return Array.isArray(value) ? value.map((item) => this.record(item)) : [];
+  }
+
+  private storageError(): InternalServerErrorException {
+    return new InternalServerErrorException({
+      code: 'COMPANY_SIGNATURE_STORAGE_ERROR',
+      message: 'No se pudo almacenar la firma remota',
+    });
+  }
+}

From 343dbe086f889538c741ccdd573d9dd9ff5c12fd Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:38:40 -0300
Subject: [PATCH 070/224] F4: expose secure remote company signature endpoints

---
 .../company-signature-invite.controller.ts    | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 api-v3/src/inspection-closing/company-signature-invite.controller.ts

diff --git a/api-v3/src/inspection-closing/company-signature-invite.controller.ts b/api-v3/src/inspection-closing/company-signature-invite.controller.ts
new file mode 100644
index 0000000..d1a4b93
--- /dev/null
+++ b/api-v3/src/inspection-closing/company-signature-invite.controller.ts
@@ -0,0 +1,77 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Post,
+  Req,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
+import { Public } from '../auth/decorators/public.decorator';
+import { SkipCsrf } from '../auth/decorators/skip-csrf.decorator';
+import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import { CompanySignatureInviteService } from './company-signature-invite.service';
+import {
+  CreateCompanySignatureInviteDto,
+  PublicCompanyRefusalDto,
+  PublicCompanySignatureDto,
+} from './dto/company-signature-invite.dto';
+import {
+  MAX_INSPECTION_SIGNATURE_BYTES,
+  type UploadedInspectionSignatureFile,
+} from './inspection-signature-file';
+
+@Controller('inspection-acts/:actId/company-signature-invitations')
+export class CompanySignatureInviteController {
+  constructor(private readonly invites: CompanySignatureInviteService) {}
+
+  @Post()
+  @RequirePermissions('inspection_closure.sign')
+  create(
+    @Param('actId', new ParseUUIDPipe({ version: '4' })) actId: string,
+    @Body() dto: CreateCompanySignatureInviteDto,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.invites.create(actId, dto, principal, request);
+  }
+}
+
+@Public()
+@SkipCsrf()
+@Controller('public/company-signatures')
+export class PublicCompanySignatureController {
+  constructor(private readonly invites: CompanySignatureInviteService) {}
+
+  @Get(':token')
+  view(@Param('token') token: string) {
+    return this.invites.view(token);
+  }
+
+  @Post(':token/sign')
+  @UseInterceptors(FileInterceptor('file', {
+    limits: { fileSize: MAX_INSPECTION_SIGNATURE_BYTES, files: 1 },
+  }))
+  sign(
+    @Param('token') token: string,
+    @Body() dto: PublicCompanySignatureDto,
+    @UploadedFile() file: UploadedInspectionSignatureFile | undefined,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.invites.sign(token, dto, file, request);
+  }
+
+  @Post(':token/refuse')
+  refuse(
+    @Param('token') token: string,
+    @Body() dto: PublicCompanyRefusalDto,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.invites.refuse(token, dto, request);
+  }
+}

From e577e4c97664a5188013678686ff033102053a4a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:38:56 -0300
Subject: [PATCH 071/224] F4: export SMTP delivery for remote signature
 invitations

---
 api-v3/src/inspection-reports/inspection-reports.module.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api-v3/src/inspection-reports/inspection-reports.module.ts b/api-v3/src/inspection-reports/inspection-reports.module.ts
index 6f5d076..4696531 100644
--- a/api-v3/src/inspection-reports/inspection-reports.module.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.module.ts
@@ -28,6 +28,6 @@ import { SmtpDeliveryService } from './smtp-delivery.service';
     InspectionDocumentDeliveryService,
     SmtpDeliveryService,
   ],
-  exports: [InspectionReportsService],
+  exports: [InspectionReportsService, SmtpDeliveryService],
 })
 export class InspectionReportsModule {}

From bdcf193a9058c9b9a6a4867fdebf8fcb6f633165 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:39:05 -0300
Subject: [PATCH 072/224] F4: wire remote company signature workflow

---
 .../inspection-closing.module.ts                   | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/api-v3/src/inspection-closing/inspection-closing.module.ts b/api-v3/src/inspection-closing/inspection-closing.module.ts
index 4ea68b5..8a264e6 100644
--- a/api-v3/src/inspection-closing/inspection-closing.module.ts
+++ b/api-v3/src/inspection-closing/inspection-closing.module.ts
@@ -1,6 +1,11 @@
 import { Module } from '@nestjs/common';
 import { AuditModule } from '../audit/audit.module';
 import { InspectionReportsModule } from '../inspection-reports/inspection-reports.module';
+import {
+  CompanySignatureInviteController,
+  PublicCompanySignatureController,
+} from './company-signature-invite.controller';
+import { CompanySignatureInviteService } from './company-signature-invite.service';
 import {
   InspectionClosingController,
   InspectionSignatureContentController,
@@ -9,7 +14,12 @@ import { InspectionClosingService } from './inspection-closing.service';
 
 @Module({
   imports: [AuditModule, InspectionReportsModule],
-  controllers: [InspectionClosingController, InspectionSignatureContentController],
-  providers: [InspectionClosingService],
+  controllers: [
+    InspectionClosingController,
+    InspectionSignatureContentController,
+    CompanySignatureInviteController,
+    PublicCompanySignatureController,
+  ],
+  providers: [InspectionClosingService, CompanySignatureInviteService],
 })
 export class InspectionClosingModule {}

From f4e5480ac8459fe2ecef03ceed86a456049e3268 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:42:26 -0300
Subject: [PATCH 073/224] F4 WEB: add public secure Act signature page

---
 web-v2/src/pages/CompanySignaturePage.tsx | 414 ++++++++++++++++++++++
 1 file changed, 414 insertions(+)
 create mode 100644 web-v2/src/pages/CompanySignaturePage.tsx

diff --git a/web-v2/src/pages/CompanySignaturePage.tsx b/web-v2/src/pages/CompanySignaturePage.tsx
new file mode 100644
index 0000000..edbb826
--- /dev/null
+++ b/web-v2/src/pages/CompanySignaturePage.tsx
@@ -0,0 +1,414 @@
+import { useEffect, useRef, useState } from 'react';
+import type { FormEvent, PointerEvent as ReactPointerEvent } from 'react';
+import { useSearchParams } from 'react-router';
+
+interface PublicFinding {
+  id: string;
+  code: string;
+  title: string;
+  description: string;
+  legalBasis: string | null;
+  severity: number | null;
+  isRecurrence: boolean;
+  recurrenceOfFindingId: string | null;
+}
+
+interface PublicInventory {
+  id: string;
+  code: string;
+  name: string;
+  typeName: string | null;
+}
+
+interface PublicSignatureView {
+  invitation: {
+    id: string;
+    recipientEmail: string;
+    expiresAt: string;
+  };
+  act: {
+    code: string;
+    inspectionCode: string;
+    lockedAt: string;
+    lockedSha256: string;
+    urgency: string | null;
+    summary: string | null;
+    observations: string | null;
+  };
+  responsibleDefaults: {
+    fullName: string | null;
+    documentType: string | null;
+    documentNumber: string | null;
+    position: string | null;
+  };
+  inventories: PublicInventory[];
+  findings: PublicFinding[];
+  consent: string;
+  allowedActions: string[];
+}
+
+interface ApiProblem {
+  message?: string;
+  code?: string;
+}
+
+const API_BASE = '/api/v3/public/company-signatures';
+
+const shellStyle: React.CSSProperties = {
+  minHeight: '100vh',
+  background: '#f3f6f8',
+  padding: '32px 16px 56px',
+  color: '#17313f',
+};
+
+const cardStyle: React.CSSProperties = {
+  maxWidth: 900,
+  margin: '0 auto 16px',
+  background: '#fff',
+  border: '1px solid #d8e1e7',
+  borderRadius: 16,
+  padding: 24,
+  boxShadow: '0 8px 30px rgba(23,49,63,.06)',
+};
+
+const gridStyle: React.CSSProperties = {
+  display: 'grid',
+  gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))',
+  gap: 12,
+};
+
+const fieldStyle: React.CSSProperties = {
+  width: '100%',
+  border: '1px solid #b8c7d0',
+  borderRadius: 9,
+  padding: '11px 12px',
+  font: 'inherit',
+  boxSizing: 'border-box',
+};
+
+const primaryButtonStyle: React.CSSProperties = {
+  border: 0,
+  borderRadius: 10,
+  padding: '12px 16px',
+  fontWeight: 700,
+  cursor: 'pointer',
+  background: '#0d5f78',
+  color: '#fff',
+};
+
+const secondaryButtonStyle: React.CSSProperties = {
+  ...primaryButtonStyle,
+  border: '1px solid #9fb3be',
+  background: '#fff',
+  color: '#17313f',
+};
+
+async function problem(response: Response): Promise<string> {
+  const body = await response.json().catch(() => ({} as ApiProblem)) as ApiProblem;
+  if (body.message) return body.message;
+  if (response.status === 410) return 'Este enlace ya fue utilizado o venció.';
+  if (response.status === 404) return 'El enlace de firma no es válido.';
+  return `No se pudo completar la operación (HTTP ${response.status}).`;
+}
+
+function SignaturePad({ disabled, onClearReady }: { disabled: boolean; onClearReady?: (clear: () => void) => void }) {
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const drawing = useRef(false);
+  const [hasInk, setHasInk] = useState(false);
+
+  const clear = () => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    canvas.getContext('2d')?.clearRect(0, 0, canvas.width, canvas.height);
+    setHasInk(false);
+  };
+
+  useEffect(() => {
+    onClearReady?.(clear);
+  }, [onClearReady]);
+
+  const point = (event: ReactPointerEvent<HTMLCanvasElement>) => {
+    const canvas = canvasRef.current;
+    if (!canvas) return null;
+    const rect = canvas.getBoundingClientRect();
+    return {
+      x: (event.clientX - rect.left) * (canvas.width / rect.width),
+      y: (event.clientY - rect.top) * (canvas.height / rect.height),
+    };
+  };
+
+  const start = (event: ReactPointerEvent<HTMLCanvasElement>) => {
+    if (disabled) return;
+    const canvas = canvasRef.current;
+    const p = point(event);
+    if (!canvas || !p) return;
+    canvas.setPointerCapture(event.pointerId);
+    const ctx = canvas.getContext('2d');
+    if (!ctx) return;
+    ctx.strokeStyle = '#102a36';
+    ctx.lineWidth = 3;
+    ctx.lineCap = 'round';
+    ctx.lineJoin = 'round';
+    ctx.beginPath();
+    ctx.moveTo(p.x, p.y);
+    drawing.current = true;
+  };
+
+  const move = (event: ReactPointerEvent<HTMLCanvasElement>) => {
+    if (!drawing.current || disabled) return;
+    const p = point(event);
+    const ctx = canvasRef.current?.getContext('2d');
+    if (!p || !ctx) return;
+    ctx.lineTo(p.x, p.y);
+    ctx.stroke();
+    setHasInk(true);
+  };
+
+  const stop = () => {
+    drawing.current = false;
+  };
+
+  return (
+    <div>
+      <canvas
+        ref={canvasRef}
+        width={900}
+        height={260}
+        onPointerDown={start}
+        onPointerMove={move}
+        onPointerUp={stop}
+        onPointerCancel={stop}
+        style={{
+          width: '100%',
+          height: 210,
+          border: '1px solid #9fb3be',
+          borderRadius: 10,
+          background: '#fff',
+          touchAction: 'none',
+          opacity: disabled ? .55 : 1,
+        }}
+        aria-label="Área para firma manuscrita"
+      />
+      <div style={{ display: 'flex', justifyContent: 'space-between', gap: 12, marginTop: 8 }}>
+        <small style={{ color: '#5c707b' }}>{hasInk ? 'Firma capturada.' : 'Firmá dentro del recuadro.'}</small>
+        <button type="button" style={secondaryButtonStyle} onClick={clear} disabled={disabled || !hasInk}>Limpiar firma</button>
+      </div>
+    </div>
+  );
+}
+
+export function CompanySignaturePage() {
+  const [params] = useSearchParams();
+  const token = params.get('token')?.trim() ?? '';
+  const [view, setView] = useState<PublicSignatureView | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [submitting, setSubmitting] = useState(false);
+  const [error, setError] = useState('');
+  const [done, setDone] = useState('');
+  const [action, setAction] = useState<'CONFORMITY' | 'DISSENT' | 'REFUSE'>('CONFORMITY');
+  const [fullName, setFullName] = useState('');
+  const [documentType, setDocumentType] = useState('DNI');
+  const [documentNumber, setDocumentNumber] = useState('');
+  const [position, setPosition] = useState('');
+  const [statement, setStatement] = useState('');
+  const [refusalReason, setRefusalReason] = useState('');
+  const [consent, setConsent] = useState(false);
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    const load = async () => {
+      if (!token) {
+        setError('El enlace no contiene un token de firma.');
+        setLoading(false);
+        return;
+      }
+      try {
+        const response = await fetch(`${API_BASE}/${encodeURIComponent(token)}`, {
+          credentials: 'omit',
+          headers: { Accept: 'application/json' },
+        });
+        if (!response.ok) throw new Error(await problem(response));
+        const data = await response.json() as PublicSignatureView;
+        if (cancelled) return;
+        setView(data);
+        setFullName(data.responsibleDefaults.fullName ?? '');
+        setDocumentType(data.responsibleDefaults.documentType ?? 'DNI');
+        setDocumentNumber(data.responsibleDefaults.documentNumber ?? '');
+        setPosition(data.responsibleDefaults.position ?? '');
+      } catch (loadError) {
+        if (!cancelled) setError(loadError instanceof Error ? loadError.message : 'No se pudo abrir el enlace.');
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    };
+    void load();
+    return () => { cancelled = true; };
+  }, [token]);
+
+  const identityValid = fullName.trim().length >= 2
+    && documentNumber.trim().length >= 3
+    && position.trim().length >= 2;
+
+  const submit = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!view || !token || !identityValid) return;
+    setError('');
+    setSubmitting(true);
+    try {
+      if (action === 'REFUSE') {
+        if (refusalReason.trim().length < 10) {
+          throw new Error('Explicá el motivo de la negativa con al menos 10 caracteres.');
+        }
+        const response = await fetch(`${API_BASE}/${encodeURIComponent(token)}/refuse`, {
+          method: 'POST',
+          credentials: 'omit',
+          headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+          body: JSON.stringify({
+            fullName: fullName.trim(),
+            documentType,
+            documentNumber: documentNumber.trim(),
+            position: position.trim(),
+            reason: refusalReason.trim(),
+          }),
+        });
+        if (!response.ok) throw new Error(await problem(response));
+        setDone(`Negativa registrada para ${view.act.code}. Este enlace ya no puede volver a utilizarse.`);
+        return;
+      }
+
+      if (!consent) throw new Error('Debés aceptar la constancia antes de firmar.');
+      if (action === 'DISSENT' && statement.trim().length < 10) {
+        throw new Error('Escribí la manifestación de disidencia con al menos 10 caracteres.');
+      }
+      const canvas = document.querySelector('canvas[aria-label="Área para firma manuscrita"]') as HTMLCanvasElement | null;
+      canvasRef.current = canvas;
+      if (!canvas) throw new Error('No se encontró el área de firma.');
+      const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, 'image/png'));
+      if (!blob) throw new Error('No se pudo capturar la firma.');
+      const imageData = canvas.getContext('2d')?.getImageData(0, 0, canvas.width, canvas.height).data;
+      const hasInk = imageData ? Array.from(imageData).some((value, index) => index % 4 === 3 && value > 0) : false;
+      if (!hasInk) throw new Error('Firmá dentro del recuadro antes de continuar.');
+
+      const form = new FormData();
+      form.append('fullName', fullName.trim());
+      form.append('documentType', documentType);
+      form.append('documentNumber', documentNumber.trim());
+      form.append('position', position.trim());
+      form.append('manifestation', action);
+      if (action === 'DISSENT') form.append('statement', statement.trim());
+      form.append('consentAccepted', 'true');
+      form.append('file', blob, 'firma.png');
+      const response = await fetch(`${API_BASE}/${encodeURIComponent(token)}/sign`, {
+        method: 'POST',
+        credentials: 'omit',
+        headers: { Accept: 'application/json' },
+        body: form,
+      });
+      if (!response.ok) throw new Error(await problem(response));
+      setDone(
+        action === 'DISSENT'
+          ? `Firma en disidencia registrada para ${view.act.code}. Este enlace ya no puede volver a utilizarse.`
+          : `Firma registrada para ${view.act.code}. Este enlace ya no puede volver a utilizarse.`,
+      );
+    } catch (submitError) {
+      setError(submitError instanceof Error ? submitError.message : 'No se pudo registrar la manifestación.');
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  if (loading) {
+    return <main style={shellStyle}><section style={cardStyle}><h1>DH Inspección</h1><p>Validando enlace seguro…</p></section></main>;
+  }
+  if (done) {
+    return <main style={shellStyle}><section style={cardStyle}><div style={{ fontSize: 44 }}>✓</div><h1>Manifestación registrada</h1><p>{done}</p><p style={{ color: '#5c707b' }}>Podés cerrar esta ventana.</p></section></main>;
+  }
+  if (!view) {
+    return <main style={shellStyle}><section style={cardStyle}><h1>Enlace no disponible</h1><p>{error || 'No se pudo abrir el Acta.'}</p></section></main>;
+  }
+
+  return (
+    <main style={shellStyle}>
+      <section style={cardStyle}>
+        <div style={{ display: 'flex', gap: 12, alignItems: 'center', marginBottom: 18 }}>
+          <span style={{ display: 'inline-grid', placeItems: 'center', width: 46, height: 46, borderRadius: 12, background: '#0d5f78', color: '#fff', fontWeight: 800 }}>DH</span>
+          <div><strong>Dirección de Hidrocarburos</strong><div style={{ color: '#5c707b' }}>Manifestación sobre Acta de Inspección</div></div>
+        </div>
+        <h1 style={{ marginBottom: 4 }}>{view.act.code}</h1>
+        <p style={{ marginTop: 0, color: '#5c707b' }}>Inspección {view.act.inspectionCode}</p>
+        <div style={gridStyle}>
+          <div><strong>Estado</strong><div>BLOQUEADA</div></div>
+          <div><strong>Urgencia</strong><div>{view.act.urgency === 'URGENT' ? 'Urgente' : 'No urgente'}</div></div>
+          <div><strong>Vigencia del enlace</strong><div>{new Date(view.invitation.expiresAt).toLocaleString('es-AR')}</div></div>
+        </div>
+        <div style={{ marginTop: 18, padding: 12, borderRadius: 10, background: '#eef5f7', fontSize: 13, wordBreak: 'break-all' }}>
+          <strong>Hash del contenido bloqueado</strong><br />{view.act.lockedSha256}
+        </div>
+      </section>
+
+      <section style={cardStyle}>
+        <h2>Contenido del Acta</h2>
+        {view.act.summary && <><strong>Resumen</strong><p>{view.act.summary}</p></>}
+        {view.act.observations && <><strong>Observaciones</strong><p>{view.act.observations}</p></>}
+        <h3>Inventario inspeccionado</h3>
+        {view.inventories.length === 0 ? <p>Sin Inventario detallado.</p> : view.inventories.map((item) => (
+          <div key={item.id} style={{ padding: '9px 0', borderBottom: '1px solid #e3e9ed' }}>
+            <strong>{item.code} · {item.name}</strong>{item.typeName && <div style={{ color: '#5c707b' }}>{item.typeName}</div>}
+          </div>
+        ))}
+        <h3 style={{ marginTop: 24 }}>Hallazgos</h3>
+        {view.findings.length === 0 ? <p>El Acta no contiene Hallazgos.</p> : view.findings.map((finding) => (
+          <article key={finding.id} style={{ padding: 14, marginBottom: 10, border: '1px solid #d8e1e7', borderRadius: 10 }}>
+            <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', alignItems: 'center' }}>
+              <strong>{finding.code} · {finding.title}</strong>
+              {finding.isRecurrence && <span style={{ borderRadius: 999, padding: '3px 8px', background: '#fff0d9', color: '#7a4a00', fontSize: 12, fontWeight: 700 }}>REINCIDENCIA</span>}
+            </div>
+            <p><strong>Descripción:</strong> {finding.description}</p>
+            {finding.legalBasis && <p><strong>Base legal:</strong> {finding.legalBasis}</p>}
+            {finding.severity != null && <small>Gravedad: {finding.severity}/10</small>}
+          </article>
+        ))}
+      </section>
+
+      <form style={cardStyle} onSubmit={submit}>
+        <h2>Identificación del responsable</h2>
+        <div style={gridStyle}>
+          <label>Nombre y apellido<input style={fieldStyle} value={fullName} onChange={(event) => setFullName(event.target.value)} required /></label>
+          <label>Documento<select style={fieldStyle} value={documentType} onChange={(event) => setDocumentType(event.target.value)}><option value="DNI">DNI</option><option value="CUIL">CUIL</option><option value="PASSPORT">Pasaporte</option><option value="OTHER">Otro</option></select></label>
+          <label>Número<input style={fieldStyle} value={documentNumber} onChange={(event) => setDocumentNumber(event.target.value)} required /></label>
+          <label>Cargo<input style={fieldStyle} value={position} onChange={(event) => setPosition(event.target.value)} required /></label>
+        </div>
+
+        <h2 style={{ marginTop: 28 }}>Manifestación</h2>
+        <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
+          <button type="button" style={action === 'CONFORMITY' ? primaryButtonStyle : secondaryButtonStyle} onClick={() => setAction('CONFORMITY')}>Firmar en conformidad</button>
+          <button type="button" style={action === 'DISSENT' ? primaryButtonStyle : secondaryButtonStyle} onClick={() => setAction('DISSENT')}>Firmar en disidencia</button>
+          <button type="button" style={action === 'REFUSE' ? primaryButtonStyle : secondaryButtonStyle} onClick={() => setAction('REFUSE')}>Negarme a firmar</button>
+        </div>
+
+        {action === 'DISSENT' && <label style={{ display: 'block', marginTop: 16 }}>Manifestación de disidencia<textarea style={{ ...fieldStyle, minHeight: 110 }} value={statement} onChange={(event) => setStatement(event.target.value)} required minLength={10} /></label>}
+        {action === 'REFUSE' && <label style={{ display: 'block', marginTop: 16 }}>Motivo de negativa<textarea style={{ ...fieldStyle, minHeight: 110 }} value={refusalReason} onChange={(event) => setRefusalReason(event.target.value)} required minLength={10} /></label>}
+
+        {action !== 'REFUSE' && <div style={{ marginTop: 18 }}>
+          <h3>Firma manuscrita</h3>
+          <SignaturePad disabled={submitting} />
+          <label style={{ display: 'flex', alignItems: 'flex-start', gap: 9, marginTop: 14 }}>
+            <input type="checkbox" checked={consent} onChange={(event) => setConsent(event.target.checked)} />
+            <span>{view.consent}</span>
+          </label>
+        </div>}
+
+        {error && <div role="alert" style={{ marginTop: 16, padding: 12, borderRadius: 9, background: '#fde7e7', color: '#8c2424' }}>{error}</div>}
+        <button
+          type="submit"
+          style={{ ...primaryButtonStyle, width: '100%', marginTop: 20, opacity: submitting || !identityValid ? .6 : 1 }}
+          disabled={submitting || !identityValid}
+        >
+          {submitting ? 'Registrando…' : action === 'REFUSE' ? 'Confirmar negativa' : action === 'DISSENT' ? 'Firmar en disidencia' : 'Firmar Acta'}
+        </button>
+        <p style={{ color: '#5c707b', fontSize: 13, marginBottom: 0 }}>Esta acción es de un solo uso. La manifestación quedará vinculada al hash del Acta bloqueada.</p>
+      </form>
+    </main>
+  );
+}

From 335d327984c3512abccf989b8fe5ad375f11d7c9 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:42:56 -0300
Subject: [PATCH 074/224] F4 WEB: expose public remote Act signature route

---
 web-v2/src/app/App.tsx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/web-v2/src/app/App.tsx b/web-v2/src/app/App.tsx
index 9e8e693..7a16317 100644
--- a/web-v2/src/app/App.tsx
+++ b/web-v2/src/app/App.tsx
@@ -5,6 +5,7 @@ import { AppLayout } from '../layout/AppLayout';
 import { OperationalContextProvider } from '../context/OperationalContext';
 import { AuditPage } from '../pages/AuditPage';
 import { ChangePasswordPage } from '../pages/ChangePasswordPage';
+import { CompanySignaturePage } from '../pages/CompanySignaturePage';
 import { DashboardPage } from '../pages/DashboardPage';
 import { LoginPage } from '../pages/LoginPage';
 import { NewUserPage } from '../pages/NewUserPage';
@@ -40,6 +41,7 @@ const DocumentDeliveryPage = lazy(() => import('../pages/DocumentDeliveryPage').
 export function App() {
   return <Suspense fallback={<div className="loading-block"><span className="spinner" />Cargando módulo…</div>}><Routes>
     <Route path="/login" element={<LoginPage />} />
+    <Route path="/firma-acta" element={<CompanySignaturePage />} />
     <Route element={<ProtectedRoute />}>
       <Route path="/change-password" element={<ChangePasswordPage />} />
       <Route element={<OperationalContextProvider><AppLayout /></OperationalContextProvider>}>

From 3b4310b63a460570d5d4cf4e627582c66775b5c4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:43:15 -0300
Subject: [PATCH 075/224] F4: document remote signature and SMTP secure
 settings

---
 .env.example | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/.env.example b/.env.example
index 74abc4a..bd25df2 100644
--- a/.env.example
+++ b/.env.example
@@ -21,10 +21,20 @@ ACCESS_COOKIE_NAME=dhv2_access
 REFRESH_COOKIE_NAME=dhv2_refresh
 CSRF_COOKIE_NAME=dhv2_csrf
 
+INSPECTION_SIGNATURE_ROOT=/app/storage/asset-media/inspection-signatures
 INSPECTION_REPORT_WORD_ROOT=/app/storage/asset-media/inspection-reports-word
 INSPECTION_REPORT_REVISION_ROOT=/app/storage/asset-media/inspection-report-revisions
-
 INSPECTION_ACT_PDF_ROOT=/app/storage/asset-media/inspection-acts-pdf
+
+# Enlace público de un solo uso para firma/manifestación de empresa.
+# En producción: https://dhv2.korexlabs.com/firma-acta
+# En entorno de prueba: https://prueba.dhv2.korexlabs.com/firma-acta
+COMPANY_SIGNATURE_PUBLIC_BASE_URL=https://dhv2.korexlabs.com/firma-acta
+
+# Clave maestra de 32 bytes (64 hex o base64) para cifrar la contraseña SMTP guardada por Superadmin.
+SMTP_SETTINGS_MASTER_KEY=CHANGE_ME_WITH_32_RANDOM_BYTES
+
+# Fallback SMTP. Se usa sólo hasta que Superadmin guarde una configuración en la base de datos.
 SMTP_HOST=
 SMTP_PORT=587
 SMTP_SECURE=false

From f20cc28045b92bddb7aba8b83bff1019f0f762d8 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:43:38 -0300
Subject: [PATCH 076/224] F4: pass secure SMTP and remote signature settings to
 API

---
 docker-compose.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docker-compose.yml b/docker-compose.yml
index 12ab715..fb61c3c 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -49,9 +49,12 @@ services:
       ASSET_MEDIA_ROOT: /app/storage/asset-media
       ASSET_IMPORT_ROOT: /app/storage/asset-media/imports
       INSPECTION_EVIDENCE_ROOT: /app/storage/asset-media/inspection-findings
+      INSPECTION_SIGNATURE_ROOT: /app/storage/asset-media/inspection-signatures
       INSPECTION_REPORT_WORD_ROOT: /app/storage/asset-media/inspection-reports-word
       INSPECTION_REPORT_REVISION_ROOT: /app/storage/asset-media/inspection-report-revisions
       INSPECTION_ACT_PDF_ROOT: /app/storage/asset-media/inspection-acts-pdf
+      COMPANY_SIGNATURE_PUBLIC_BASE_URL: ${COMPANY_SIGNATURE_PUBLIC_BASE_URL:-}
+      SMTP_SETTINGS_MASTER_KEY: ${SMTP_SETTINGS_MASTER_KEY:-}
       SMTP_HOST: ${SMTP_HOST:-}
       SMTP_PORT: ${SMTP_PORT:-587}
       SMTP_SECURE: ${SMTP_SECURE:-false}

From 4caf6216de58794c585fc87b0b894428a167fbda Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 21:45:09 -0300
Subject: [PATCH 077/224] F4 WEB: add Inventory function API client

---
 web-v2/src/lib/inventoryFunctionApi.ts | 86 ++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 web-v2/src/lib/inventoryFunctionApi.ts

diff --git a/web-v2/src/lib/inventoryFunctionApi.ts b/web-v2/src/lib/inventoryFunctionApi.ts
new file mode 100644
index 0000000..1cc8dfa
--- /dev/null
+++ b/web-v2/src/lib/inventoryFunctionApi.ts
@@ -0,0 +1,86 @@
+import { apiRequest } from './api';
+
+export interface InventoryFunction {
+  id: string;
+  code: string;
+  name: string;
+  description: string | null;
+  isActive: boolean;
+  sortOrder: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface InventoryFunctionAssignment {
+  id: string;
+  assetId: string;
+  functionId: string;
+  functionCode: string;
+  functionName: string;
+  validFrom: string;
+  validUntil: string | null;
+  reason: string | null;
+  changedBy: string | null;
+  changedByUsername: string | null;
+  createdAt: string;
+}
+
+export interface InventoryFunctionHistory {
+  asset: {
+    id: string;
+    code: string;
+    name: string;
+    typeCode: string;
+    typeName: string;
+    familyCode: string | null;
+    familyName: string | null;
+  };
+  currentFunction: InventoryFunctionAssignment | null;
+  history: InventoryFunctionAssignment[];
+}
+
+export async function listInventoryFunctions(includeInactive = false) {
+  const query = includeInactive ? '?includeInactive=true' : '';
+  return (await apiRequest<{ data: InventoryFunction[] }>(`/inventory-functions${query}`)).data;
+}
+
+export function getInventoryFunctionHistory(assetId: string) {
+  return apiRequest<InventoryFunctionHistory>(`/assets/${assetId}/function-history`);
+}
+
+export function changeInventoryFunction(
+  assetId: string,
+  input: { functionId: string; effectiveAt?: string; reason?: string | null },
+) {
+  return apiRequest<InventoryFunctionHistory>(`/assets/${assetId}/function`, {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function createInventoryFunction(input: {
+  code: string;
+  name: string;
+  description?: string | null;
+  sortOrder?: number;
+}) {
+  return apiRequest<InventoryFunction>('/inventory-functions', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function updateInventoryFunction(
+  id: string,
+  input: {
+    name?: string;
+    description?: string | null;
+    isActive?: boolean;
+    sortOrder?: number;
+  },
+) {
+  return apiRequest<InventoryFunction>(`/inventory-functions/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}

From a9a6b2fa1f57ff141faa1debf23dc9c6dd82ccf8 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:09:50 -0300
Subject: [PATCH 078/224] F4 inventory: include function in temporal snapshots

---
 .../src/asset-master/asset-history.service.ts | 213 +++++-------------
 1 file changed, 55 insertions(+), 158 deletions(-)

diff --git a/api-v3/src/asset-master/asset-history.service.ts b/api-v3/src/asset-master/asset-history.service.ts
index 5dc216d..ddd9f73 100644
--- a/api-v3/src/asset-master/asset-history.service.ts
+++ b/api-v3/src/asset-master/asset-history.service.ts
@@ -41,14 +41,14 @@ export interface AssetVersionDetail extends AssetVersionSummary {
 function assetNotFound(): NotFoundException {
   return new NotFoundException({
     code: 'ASSET_NOT_FOUND',
-    message: 'Activo no encontrado',
+    message: 'Inventario no encontrado',
   });
 }
 
 function versionNotFound(): NotFoundException {
   return new NotFoundException({
     code: 'ASSET_VERSION_NOT_FOUND',
-    message: 'Versión de activo no encontrada',
+    message: 'Versión de Inventario no encontrada',
   });
 }
 
@@ -79,7 +79,7 @@ export class AssetHistoryService {
 
     const versionNumber = Number(versionRow.current_version);
     if (!Number.isInteger(versionNumber) || versionNumber < 1) {
-      throw new Error(`Versión de activo inválida después de incrementar: ${versionRow.current_version}`);
+      throw new Error(`Versión de Inventario inválida después de incrementar: ${versionRow.current_version}`);
     }
 
     const snapshot = await this.loadCurrentSnapshot(manager, assetId);
@@ -101,17 +101,8 @@ export class AssetHistoryService {
          asset_id, version_number, change_type, changed_fields, snapshot,
          actor_user_id, actor_username, source, request_id
        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
-      [
-        assetId,
-        versionNumber,
-        changeType,
-        changedFields,
-        snapshot,
-        principal.userId,
-        principal.username,
-        source,
-        request.requestId,
-      ],
+      [assetId, versionNumber, changeType, changedFields, snapshot,
+        principal.userId, principal.username, source, request.requestId],
     );
     return versionNumber;
   }
@@ -123,38 +114,21 @@ export class AssetHistoryService {
       parameters.push(value);
       return `$${parameters.length}`;
     };
-
     if (query.search?.trim()) {
       const search = add(`%${query.search.trim()}%`);
-      conditions.push(`(
-        version.snapshot->>'code' ILIKE ${search}
-        OR version.snapshot->>'name' ILIKE ${search}
-        OR version.actor_username ILIKE ${search}
-      )`);
-    }
-    if (query.typeId) {
-      conditions.push(`version.snapshot #>> '{type,id}' = ${add(query.typeId)}`);
-    }
-    if (query.status) {
-      conditions.push(`version.snapshot->>'informationStatus' = ${add(query.status)}`);
-    }
-    if (query.changeType) {
-      conditions.push(`version.change_type = ${add(query.changeType)}`);
+      conditions.push(`(version.snapshot->>'code' ILIKE ${search} OR version.snapshot->>'name' ILIKE ${search} OR version.actor_username ILIKE ${search})`);
     }
+    if (query.typeId) conditions.push(`version.snapshot #>> '{type,id}' = ${add(query.typeId)}`);
+    if (query.status) conditions.push(`version.snapshot->>'informationStatus' = ${add(query.status)}`);
+    if (query.changeType) conditions.push(`version.change_type = ${add(query.changeType)}`);
     if (query.from) conditions.push(`version.occurred_at >= ${add(new Date(query.from))}`);
     if (query.to) conditions.push(`version.occurred_at <= ${add(new Date(query.to))}`);
-
     return this.listWithConditions(query.page, query.pageSize, conditions, parameters);
   }
 
   async listForAsset(assetId: string, query: AssetVersionPageQueryDto) {
     await this.requireAsset(assetId);
-    return this.listWithConditions(
-      query.page,
-      query.pageSize,
-      ['version.asset_id = $1'],
-      [assetId],
-    );
+    return this.listWithConditions(query.page, query.pageSize, ['version.asset_id = $1'], [assetId]);
   }
 
   async getVersion(assetId: string, versionNumber: number): Promise<AssetVersionDetail> {
@@ -170,17 +144,9 @@ export class AssetHistoryService {
     return row;
   }
 
-  private async listWithConditions(
-    page: number,
-    pageSize: number,
-    conditions: string[],
-    parameters: unknown[],
-  ) {
+  private async listWithConditions(page: number, pageSize: number, conditions: string[], parameters: unknown[]) {
     const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
-    const [countRow] = (await this.dataSource.query(
-      `SELECT COUNT(*)::integer AS total FROM asset_versions version ${where}`,
-      parameters,
-    )) as Array<{ total: number }>;
+    const [countRow] = (await this.dataSource.query(`SELECT COUNT(*)::integer AS total FROM asset_versions version ${where}`, parameters)) as Array<{ total: number }>;
     const total = Number(countRow?.total ?? 0);
     const paginated = [...parameters, pageSize, (page - 1) * pageSize];
     const limit = `$${parameters.length + 1}`;
@@ -194,51 +160,29 @@ export class AssetHistoryService {
        LIMIT ${limit} OFFSET ${offset}`,
       paginated,
     )) as AssetVersionSummary[];
-
-    return {
-      data,
-      meta: {
-        page,
-        pageSize,
-        total,
-        totalPages: total === 0 ? 0 : Math.ceil(total / pageSize),
-      },
-    };
+    return { data, meta: { page, pageSize, total, totalPages: total === 0 ? 0 : Math.ceil(total / pageSize) } };
   }
 
   private selectSummary(): string {
     return `SELECT
-      version.id,
-      version.asset_id AS "assetId",
-      version.snapshot->>'code' AS "assetCode",
-      version.snapshot->>'name' AS "assetName",
-      version.snapshot #>> '{type,id}' AS "typeId",
-      version.snapshot #>> '{type,name}' AS "typeName",
+      version.id, version.asset_id AS "assetId",
+      version.snapshot->>'code' AS "assetCode", version.snapshot->>'name' AS "assetName",
+      version.snapshot #>> '{type,id}' AS "typeId", version.snapshot #>> '{type,name}' AS "typeName",
       version.snapshot->>'informationStatus' AS "informationStatus",
       version.snapshot->>'operationalStatus' AS "operationalStatus",
-      version.version_number AS "versionNumber",
-      version.change_type AS "changeType",
-      version.changed_fields AS "changedFields",
-      version.occurred_at AS "occurredAt",
-      version.actor_user_id AS "actorUserId",
-      version.actor_username AS "actorUsername",
-      version.source,
-      version.request_id AS "requestId",
+      version.version_number AS "versionNumber", version.change_type AS "changeType",
+      version.changed_fields AS "changedFields", version.occurred_at AS "occurredAt",
+      version.actor_user_id AS "actorUserId", version.actor_username AS "actorUsername",
+      version.source, version.request_id AS "requestId",
       (version.version_number = current_asset.current_version) AS "isCurrent"`;
   }
 
   private async requireAsset(assetId: string): Promise<void> {
-    const [row] = (await this.dataSource.query(
-      'SELECT 1 FROM assets WHERE id = $1',
-      [assetId],
-    )) as unknown[];
+    const [row] = (await this.dataSource.query('SELECT 1 FROM assets WHERE id = $1', [assetId])) as unknown[];
     if (!row) throw assetNotFound();
   }
 
-  private async loadCurrentSnapshot(
-    manager: EntityManager,
-    assetId: string,
-  ): Promise<Record<string, unknown>> {
+  private async loadCurrentSnapshot(manager: EntityManager, assetId: string): Promise<Record<string, unknown>> {
     const [row] = (await manager.query(
       `SELECT JSONB_BUILD_OBJECT(
          'id', asset.id,
@@ -246,82 +190,49 @@ export class AssetHistoryService {
          'name', asset.name,
          'commonName', asset.common_name,
          'description', asset.description,
-         'type', JSONB_BUILD_OBJECT(
-           'id', asset_type.id,
-           'code', asset_type.code,
-           'name', asset_type.name,
-           'operationalRole', asset_type.operational_role
-         ),
-         'parent', CASE WHEN parent.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-           'id', parent.id,
-           'code', parent.code,
-           'name', parent.name
-         ) END,
-         'operationalArea', CASE WHEN operational_area.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-           'id', operational_area.id,
-           'code', operational_area.code,
-           'name', operational_area.name
-         ) END,
-         'operatorCompany', CASE WHEN operator_company.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-           'id', operator_company.id,
-           'code', operator_company.code,
-           'name', operator_company.name
-         ) END,
+         'type', JSONB_BUILD_OBJECT('id', asset_type.id,'code', asset_type.code,'name', asset_type.name,'operationalRole', asset_type.operational_role),
+         'parent', CASE WHEN parent.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id', parent.id,'code', parent.code,'name', parent.name) END,
+         'operationalArea', CASE WHEN operational_area.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id', operational_area.id,'code', operational_area.code,'name', operational_area.name) END,
+         'operatorCompany', CASE WHEN operator_company.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id', operator_company.id,'code', operator_company.code,'name', operator_company.name) END,
          'informationStatus', asset.information_status,
          'operationalStatus', asset.operational_status,
+         'currentFunction', (
+           SELECT JSONB_BUILD_OBJECT(
+             'assignmentId', assignment.id,
+             'id', fn.id,
+             'code', fn.code,
+             'name', fn.name,
+             'validFrom', assignment.valid_from,
+             'reason', assignment.change_reason
+           )
+           FROM inventory_function_assignments assignment
+           JOIN inventory_functions fn ON fn.id=assignment.function_id
+           WHERE assignment.asset_id=asset.id AND assignment.valid_until IS NULL
+           ORDER BY assignment.valid_from DESC LIMIT 1
+         ),
          'attributes', COALESCE((
            SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
-             'definitionId', 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,
-             'value', value.value
+             'definitionId', 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,'value', value.value
            ) ORDER BY definition.sort_order, definition.name)
            FROM asset_attribute_definitions definition
-           LEFT JOIN asset_attribute_values value
-             ON value.definition_id = definition.id
-            AND value.asset_id = asset.id
-           WHERE definition.asset_type_id = asset.asset_type_id
-             AND definition.is_active = true
+           LEFT JOIN asset_attribute_values value ON value.definition_id = definition.id AND value.asset_id = asset.id
+           WHERE definition.asset_type_id = asset.asset_type_id AND definition.is_active = true
          ), '[]'::jsonb),
          'geometry', CASE WHEN geometry.asset_id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-           'assetId', geometry.asset_id,
-           'geometry', ST_AsGeoJSON(geometry.geometry)::jsonb,
-           'geometryType', geometry.geometry_type,
-           'source', geometry.source,
-           'accuracyM', geometry.accuracy_m::double precision,
-           'capturedAt', geometry.captured_at,
-           'deviceLabel', geometry.device_label,
-           'createdAt', geometry.created_at,
-           'updatedAt', geometry.updated_at,
-           'updatedBy', geometry.updated_by
+           'assetId', geometry.asset_id,'geometry', ST_AsGeoJSON(geometry.geometry)::jsonb,'geometryType', geometry.geometry_type,
+           'source', geometry.source,'accuracyM', geometry.accuracy_m::double precision,'capturedAt', geometry.captured_at,
+           'deviceLabel', geometry.device_label,'createdAt', geometry.created_at,'updatedAt', geometry.updated_at,'updatedBy', geometry.updated_by
          ) END,
          'media', COALESCE((
            SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
-             'id', media.id,
-             'kind', media.kind,
-             'originalName', media.original_name,
-             'mimeType', media.mime_type,
-             'sizeBytes', media.size_bytes,
-             'sha256', media.sha256,
-             'title', media.title,
-             'description', media.description,
-             'capturedAt', media.captured_at,
-             'latitude', media.latitude,
-             'longitude', media.longitude,
-             'accuracyM', media.accuracy_m,
-             'source', media.source,
-             'uploadedBy', media.uploaded_by,
-             'createdAt', media.created_at,
-             'updatedAt', media.updated_at
+             'id', media.id,'kind', media.kind,'originalName', media.original_name,'mimeType', media.mime_type,
+             'sizeBytes', media.size_bytes,'sha256', media.sha256,'title', media.title,'description', media.description,
+             'capturedAt', media.captured_at,'latitude', media.latitude,'longitude', media.longitude,'accuracyM', media.accuracy_m,
+             'source', media.source,'uploadedBy', media.uploaded_by,'createdAt', media.created_at,'updatedAt', media.updated_at
            ) ORDER BY media.created_at, media.id)
-           FROM asset_media media
-           WHERE media.asset_id = asset.id
-             AND media.deleted_at IS NULL
+           FROM asset_media media WHERE media.asset_id = asset.id AND media.deleted_at IS NULL
          ), '[]'::jsonb),
          'organizationProfile', (SELECT TO_JSONB(profile) - 'created_at' - 'updated_at' FROM organization_profiles profile WHERE profile.asset_id=asset.id),
          'organizationMemberships', COALESCE((
@@ -337,22 +248,8 @@ export class AssetHistoryService {
          'legalRights', COALESCE((
            SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',r.id,'rightType',r.right_type,'name',r.name,'instrumentNumber',r.instrument_number,'validFrom',r.valid_from,'validUntil',r.valid_until,'status',r.status,'sourceDocumentId',r.source_document_id,'notes',r.notes,'organizations',COALESCE((SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',o.id,'organizationId',o.organization_id,'role',o.role,'participationPercent',o.participation_percent::double precision,'validFrom',o.valid_from,'validUntil',o.valid_until,'notes',o.notes,'endReason',o.end_reason) ORDER BY o.valid_until NULLS FIRST,o.valid_from DESC) FROM area_legal_right_organizations o WHERE o.right_id=r.id),'[]'::jsonb)) ORDER BY r.valid_until DESC NULLS FIRST,r.valid_from DESC NULLS LAST) FROM area_legal_rights r WHERE r.area_id=asset.id
          ),'[]'::jsonb),
-         'provenance', JSONB_BUILD_OBJECT(
-           'origin', asset.data_origin,
-           'sourceName', asset.source_name,
-           'sourceReference', asset.source_reference,
-           'observedAt', asset.source_observed_at,
-           'notes', asset.source_notes,
-           'verifiedAt', asset.provenance_verified_at,
-           'verifiedBy', asset.provenance_verified_by,
-           'updatedAt', asset.provenance_updated_at,
-           'updatedBy', asset.provenance_updated_by
-         ),
-         'createdAt', asset.created_at,
-         'updatedAt', asset.updated_at,
-         'createdBy', asset.created_by,
-         'updatedBy', asset.updated_by,
-         'currentVersion', asset.current_version
+         'provenance', JSONB_BUILD_OBJECT('origin', asset.data_origin,'sourceName', asset.source_name,'sourceReference', asset.source_reference,'observedAt', asset.source_observed_at,'notes', asset.source_notes,'verifiedAt', asset.provenance_verified_at,'verifiedBy', asset.provenance_verified_by,'updatedAt', asset.provenance_updated_at,'updatedBy', asset.provenance_updated_by),
+         'createdAt', asset.created_at,'updatedAt', asset.updated_at,'createdBy', asset.created_by,'updatedBy', asset.updated_by,'currentVersion', asset.current_version
        ) AS snapshot
        FROM assets asset
        INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id

From 747ad21262baef56f097e6253d31e5d0c88060d5 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:11:10 -0300
Subject: [PATCH 079/224] F4 inventory: version function changes in dossier
 history

---
 .../inventory-function.service.ts             | 261 ++++--------------
 1 file changed, 52 insertions(+), 209 deletions(-)

diff --git a/api-v3/src/asset-master/inventory-function.service.ts b/api-v3/src/asset-master/inventory-function.service.ts
index 8b5c644..1a2e315 100644
--- a/api-v3/src/asset-master/inventory-function.service.ts
+++ b/api-v3/src/asset-master/inventory-function.service.ts
@@ -8,55 +8,32 @@ import { DataSource, EntityManager } from 'typeorm';
 import { administrationAuditContext } from '../administration/common/administration-audit';
 import { AuditService } from '../audit/audit.service';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { AuditAction } from '../database/entities';
+import { AssetVersionChangeType, AuditAction } from '../database/entities';
 import type {
   ChangeInventoryFunctionDto,
   CreateInventoryFunctionDto,
   UpdateInventoryFunctionDto,
 } from './dto/inventory-function.dto';
+import { AssetHistoryService } from './asset-history.service';
 
 interface InventoryFunctionRow {
-  id: string;
-  code: string;
-  name: string;
-  description: string | null;
-  isActive: boolean;
-  sortOrder: number;
-  createdAt: Date;
-  updatedAt: Date;
+  id: string; code: string; name: string; description: string | null;
+  isActive: boolean; sortOrder: number; createdAt: Date; updatedAt: Date;
 }
 
 interface FunctionAssignmentRow {
-  id: string;
-  assetId: string;
-  functionId: string;
-  functionCode: string;
-  functionName: string;
-  validFrom: Date;
-  validUntil: Date | null;
-  reason: string | null;
-  changedBy: string | null;
-  changedByUsername: string | null;
-  createdAt: Date;
+  id: string; assetId: string; functionId: string; functionCode: string; functionName: string;
+  validFrom: Date; validUntil: Date | null; reason: string | null;
+  changedBy: string | null; changedByUsername: string | null; createdAt: Date;
 }
 
 interface FunctionEligibleAsset {
-  id: string;
-  code: string;
-  name: string;
-  typeCode: string;
-  typeName: string;
-  familyCode: string | null;
-  familyName: string | null;
+  id: string; code: string; name: string; typeCode: string; typeName: string;
+  familyCode: string | null; familyName: string | null;
 }
 
 function normalized(value: string | null): string {
-  return (value ?? '')
-    .normalize('NFD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim();
+  return (value ?? '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
 }
 
 @Injectable()
@@ -64,6 +41,7 @@ export class InventoryFunctionService {
   constructor(
     private readonly dataSource: DataSource,
     private readonly audit: AuditService,
+    private readonly history: AssetHistoryService,
   ) {}
 
   async list(includeInactive = false): Promise<{ data: InventoryFunctionRow[] }> {
@@ -77,77 +55,38 @@ export class InventoryFunctionService {
     return { data };
   }
 
-  async create(
-    dto: CreateInventoryFunctionDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InventoryFunctionRow> {
+  async create(dto: CreateInventoryFunctionDto, principal: AuthPrincipal, request: RequestWithContext): Promise<InventoryFunctionRow> {
     return this.dataSource.transaction(async (manager) => {
-      const [duplicate] = await manager.query(
-        'SELECT 1 FROM inventory_functions WHERE lower(code)=lower($1) LIMIT 1',
-        [dto.code],
-      ) as unknown[];
-      if (duplicate) {
-        throw new ConflictException({
-          code: 'INVENTORY_FUNCTION_CODE_EXISTS',
-          message: 'Ya existe una función con ese código',
-        });
-      }
+      const [duplicate] = await manager.query('SELECT 1 FROM inventory_functions WHERE lower(code)=lower($1) LIMIT 1', [dto.code]) as unknown[];
+      if (duplicate) throw new ConflictException({ code: 'INVENTORY_FUNCTION_CODE_EXISTS', message: 'Ya existe una función con ese código' });
       const [created] = await manager.query(`
         INSERT INTO inventory_functions(code,name,description,is_active,sort_order,created_by,updated_by)
         VALUES($1,$2,$3,true,$4,$5,$5)
         RETURNING id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",
           created_at AS "createdAt",updated_at AS "updatedAt"
       `, [dto.code, dto.name, dto.description ?? null, dto.sortOrder ?? 0, principal.userId]) as InventoryFunctionRow[];
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INVENTORY_FUNCTION_CREATED,
-        entityType: 'inventory_function',
-        entityId: created.id,
-        afterData: created as unknown as Record<string, unknown>,
-      }, manager);
+      await this.audit.record({ ...administrationAuditContext(principal, request), action: AuditAction.INVENTORY_FUNCTION_CREATED,
+        entityType: 'inventory_function', entityId: created.id, afterData: created as unknown as Record<string, unknown> }, manager);
       return created;
     });
   }
 
-  async update(
-    id: string,
-    dto: UpdateInventoryFunctionDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InventoryFunctionRow> {
-    if (Object.keys(dto).length === 0) {
-      throw new BadRequestException({ code: 'NO_CHANGES', message: 'No se recibieron cambios' });
-    }
+  async update(id: string, dto: UpdateInventoryFunctionDto, principal: AuthPrincipal, request: RequestWithContext): Promise<InventoryFunctionRow> {
+    if (Object.keys(dto).length === 0) throw new BadRequestException({ code: 'NO_CHANGES', message: 'No se recibieron cambios' });
     return this.dataSource.transaction(async (manager) => {
       const before = await this.requireFunction(manager, id, false);
       const [updated] = await manager.query(`
         UPDATE inventory_functions SET
-          name=COALESCE($2,name),
-          description=CASE WHEN $3::boolean THEN $4 ELSE description END,
-          is_active=COALESCE($5,is_active),
-          sort_order=COALESCE($6,sort_order),
+          name=COALESCE($2,name), description=CASE WHEN $3::boolean THEN $4 ELSE description END,
+          is_active=COALESCE($5,is_active), sort_order=COALESCE($6,sort_order),
           updated_by=$7,updated_at=CURRENT_TIMESTAMP
         WHERE id=$1
         RETURNING id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",
           created_at AS "createdAt",updated_at AS "updatedAt"
-      `, [
-        id,
-        dto.name ?? null,
-        dto.description !== undefined,
-        dto.description ?? null,
-        dto.isActive ?? null,
-        dto.sortOrder ?? null,
-        principal.userId,
-      ]) as InventoryFunctionRow[];
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INVENTORY_FUNCTION_UPDATED,
-        entityType: 'inventory_function',
-        entityId: id,
-        beforeData: before as unknown as Record<string, unknown>,
-        afterData: updated as unknown as Record<string, unknown>,
-      }, manager);
+      `, [id, dto.name ?? null, dto.description !== undefined, dto.description ?? null, dto.isActive ?? null, dto.sortOrder ?? null, principal.userId]) as InventoryFunctionRow[];
+      await this.audit.record({ ...administrationAuditContext(principal, request), action: AuditAction.INVENTORY_FUNCTION_UPDATED,
+        entityType: 'inventory_function', entityId: id, beforeData: before as unknown as Record<string, unknown>,
+        afterData: updated as unknown as Record<string, unknown> }, manager);
       return updated;
     });
   }
@@ -156,80 +95,32 @@ export class InventoryFunctionService {
     return this.dataSource.transaction((manager) => this.getForAssetWithManager(manager, assetId));
   }
 
-  async changeForAsset(
-    assetId: string,
-    dto: ChangeInventoryFunctionDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ) {
+  async changeForAsset(assetId: string, dto: ChangeInventoryFunctionDto, principal: AuthPrincipal, request: RequestWithContext) {
     return this.dataSource.transaction(async (manager) => {
       const asset = await this.requireEligibleAsset(manager, assetId, true);
       const nextFunction = await this.requireFunction(manager, dto.functionId, true);
       const effectiveAt = dto.effectiveAt ? new Date(dto.effectiveAt) : new Date();
-      if (!Number.isFinite(effectiveAt.getTime())) {
-        throw new BadRequestException({
-          code: 'INVENTORY_FUNCTION_EFFECTIVE_DATE_INVALID',
-          message: 'La fecha efectiva del cambio de función no es válida',
-        });
-      }
-      if (effectiveAt.getTime() > Date.now() + 60_000) {
-        throw new BadRequestException({
-          code: 'INVENTORY_FUNCTION_FUTURE_DATE_NOT_ALLOWED',
-          message: 'El cambio de función no puede registrarse con fecha futura',
-        });
-      }
+      if (!Number.isFinite(effectiveAt.getTime())) throw new BadRequestException({ code: 'INVENTORY_FUNCTION_EFFECTIVE_DATE_INVALID', message: 'La fecha efectiva del cambio de función no es válida' });
+      if (effectiveAt.getTime() > Date.now() + 60_000) throw new BadRequestException({ code: 'INVENTORY_FUNCTION_FUTURE_DATE_NOT_ALLOWED', message: 'El cambio de función no puede registrarse con fecha futura' });
 
       const current = await this.currentAssignment(manager, assetId, true);
-      if (current?.functionId === nextFunction.id) {
-        return this.getForAssetWithManager(manager, assetId);
-      }
+      if (current?.functionId === nextFunction.id) return this.getForAssetWithManager(manager, assetId);
       if (current && effectiveAt.getTime() <= new Date(current.validFrom).getTime()) {
-        throw new ConflictException({
-          code: 'INVENTORY_FUNCTION_EFFECTIVE_DATE_OVERLAP',
-          message: 'La fecha efectiva debe ser posterior al inicio de la función vigente',
-        });
+        throw new ConflictException({ code: 'INVENTORY_FUNCTION_EFFECTIVE_DATE_OVERLAP', message: 'La fecha efectiva debe ser posterior al inicio de la función vigente' });
       }
+      if (current) await manager.query(`UPDATE inventory_function_assignments SET valid_until=$2 WHERE id=$1 AND valid_until IS NULL`, [current.id, effectiveAt]);
+      await manager.query(`INSERT INTO inventory_function_assignments(asset_id,function_id,valid_from,change_reason,changed_by) VALUES($1,$2,$3,$4,$5)`,
+        [assetId, nextFunction.id, effectiveAt, dto.reason ?? null, principal.userId]);
+      await manager.query(`UPDATE assets SET updated_by=$2,updated_at=CURRENT_TIMESTAMP WHERE id=$1`, [assetId, principal.userId]);
 
-      if (current) {
-        await manager.query(`
-          UPDATE inventory_function_assignments
-          SET valid_until=$2
-          WHERE id=$1 AND valid_until IS NULL
-        `, [current.id, effectiveAt]);
-      }
-      await manager.query(`
-        INSERT INTO inventory_function_assignments(
-          asset_id,function_id,valid_from,change_reason,changed_by
-        ) VALUES($1,$2,$3,$4,$5)
-      `, [assetId, nextFunction.id, effectiveAt, dto.reason ?? null, principal.userId]);
-      await manager.query(`
-        UPDATE assets SET updated_by=$2,updated_at=CURRENT_TIMESTAMP WHERE id=$1
-      `, [assetId, principal.userId]);
+      const versionNumber = await this.history.capture(manager, assetId, AssetVersionChangeType.FUNCTION_CHANGED, principal, request);
       const after = await this.getForAssetWithManager(manager, assetId);
       await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.ASSET_FUNCTION_CHANGED,
-        entityType: 'asset',
-        entityId: assetId,
-        beforeData: current ? {
-          functionId: current.functionId,
-          functionCode: current.functionCode,
-          functionName: current.functionName,
-          validFrom: current.validFrom,
-        } : { functionId: null },
-        afterData: {
-          functionId: nextFunction.id,
-          functionCode: nextFunction.code,
-          functionName: nextFunction.name,
-          effectiveAt,
-          reason: dto.reason ?? null,
-        },
-        metadata: {
-          inventoryCode: asset.code,
-          inventoryName: asset.name,
-          temporal: true,
-          historySource: 'inventory_function_assignments',
-        },
+        ...administrationAuditContext(principal, request), action: AuditAction.ASSET_FUNCTION_CHANGED,
+        entityType: 'asset', entityId: assetId,
+        beforeData: current ? { functionId: current.functionId, functionCode: current.functionCode, functionName: current.functionName, validFrom: current.validFrom } : { functionId: null },
+        afterData: { functionId: nextFunction.id, functionCode: nextFunction.code, functionName: nextFunction.name, effectiveAt, reason: dto.reason ?? null, versionNumber },
+        metadata: { inventoryCode: asset.code, inventoryName: asset.name, temporal: true, historySource: 'inventory_function_assignments', assetVersionChangeType: AssetVersionChangeType.FUNCTION_CHANGED },
       }, manager);
       return after;
     });
@@ -250,26 +141,10 @@ export class InventoryFunctionService {
       WHERE assignment.asset_id=$1
       ORDER BY assignment.valid_from DESC,assignment.created_at DESC
     `, [assetId]) as FunctionAssignmentRow[];
-    return {
-      asset: {
-        id: asset.id,
-        code: asset.code,
-        name: asset.name,
-        typeCode: asset.typeCode,
-        typeName: asset.typeName,
-        familyCode: asset.familyCode,
-        familyName: asset.familyName,
-      },
-      currentFunction,
-      history,
-    };
+    return { asset: { id: asset.id, code: asset.code, name: asset.name, typeCode: asset.typeCode, typeName: asset.typeName, familyCode: asset.familyCode, familyName: asset.familyName }, currentFunction, history };
   }
 
-  private async currentAssignment(
-    manager: EntityManager,
-    assetId: string,
-    lock: boolean,
-  ): Promise<FunctionAssignmentRow | null> {
+  private async currentAssignment(manager: EntityManager, assetId: string, lock: boolean): Promise<FunctionAssignmentRow | null> {
     const [row] = await manager.query(`
       SELECT assignment.id,assignment.asset_id AS "assetId",assignment.function_id AS "functionId",
         fn.code AS "functionCode",fn.name AS "functionName",
@@ -285,59 +160,27 @@ export class InventoryFunctionService {
     return row ?? null;
   }
 
-  private async requireFunction(
-    manager: EntityManager,
-    id: string,
-    active: boolean,
-  ): Promise<InventoryFunctionRow> {
+  private async requireFunction(manager: EntityManager, id: string, active: boolean): Promise<InventoryFunctionRow> {
     const [row] = await manager.query(`
-      SELECT id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",
-        created_at AS "createdAt",updated_at AS "updatedAt"
-      FROM inventory_functions
-      WHERE id=$1 ${active ? 'AND is_active=true' : ''}
+      SELECT id,code,name,description,is_active AS "isActive",sort_order AS "sortOrder",created_at AS "createdAt",updated_at AS "updatedAt"
+      FROM inventory_functions WHERE id=$1 ${active ? 'AND is_active=true' : ''}
     `, [id]) as InventoryFunctionRow[];
-    if (!row) {
-      throw new NotFoundException({
-        code: 'INVENTORY_FUNCTION_NOT_FOUND',
-        message: active ? 'La función seleccionada no existe o está inactiva' : 'Función no encontrada',
-      });
-    }
+    if (!row) throw new NotFoundException({ code: 'INVENTORY_FUNCTION_NOT_FOUND', message: active ? 'La función seleccionada no existe o está inactiva' : 'Función no encontrada' });
     return row;
   }
 
-  private async requireEligibleAsset(
-    manager: EntityManager,
-    assetId: string,
-    lock: boolean,
-  ): Promise<FunctionEligibleAsset> {
+  private async requireEligibleAsset(manager: EntityManager, assetId: string, lock: boolean): Promise<FunctionEligibleAsset> {
     const [asset] = await manager.query(`
-      SELECT asset.id,asset.code,asset.name,
-        asset_type.code AS "typeCode",asset_type.name AS "typeName",
+      SELECT asset.id,asset.code,asset.name,asset_type.code AS "typeCode",asset_type.name AS "typeName",
         family.code AS "familyCode",family.name AS "familyName"
-      FROM assets asset
-      JOIN asset_types asset_type ON asset_type.id=asset.asset_type_id
+      FROM assets asset JOIN asset_types asset_type ON asset_type.id=asset.asset_type_id
       LEFT JOIN inventory_families family ON family.id=asset.inventory_family_id
-      WHERE asset.id=$1
-      ${lock ? 'FOR UPDATE OF asset' : ''}
+      WHERE asset.id=$1 ${lock ? 'FOR UPDATE OF asset' : ''}
     `, [assetId]) as FunctionEligibleAsset[];
-    if (!asset) {
-      throw new NotFoundException({ code: 'ASSET_NOT_FOUND', message: 'Inventario no encontrado' });
-    }
+    if (!asset) throw new NotFoundException({ code: 'ASSET_NOT_FOUND', message: 'Inventario no encontrado' });
     const values = [asset.typeCode, asset.typeName, asset.familyCode, asset.familyName].map(normalized);
-    const eligible = values.some((value) =>
-      value === 'estacion'
-      || value === 'subestacion'
-      || value.includes('estacion ')
-      || value.includes('subestacion ')
-      || value.endsWith(' estacion')
-      || value.endsWith(' subestacion'),
-    );
-    if (!eligible) {
-      throw new ConflictException({
-        code: 'INVENTORY_FUNCTION_CHANGE_NOT_ALLOWED',
-        message: 'El cambio de función sólo está habilitado para Inventarios de Estación o Subestación',
-      });
-    }
+    const eligible = values.some((value) => value === 'estacion' || value === 'subestacion' || value.includes('estacion ') || value.includes('subestacion ') || value.endsWith(' estacion') || value.endsWith(' subestacion'));
+    if (!eligible) throw new ConflictException({ code: 'INVENTORY_FUNCTION_CHANGE_NOT_ALLOWED', message: 'El cambio de función sólo está habilitado para Inventarios de Estación o Subestación' });
     return asset;
   }
 }

From 30f543ad08bc30b735c5f6a7d8b4a20a5ca424e0 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:16:05 -0300
Subject: [PATCH 080/224] F4 findings: center detail on immutable description
 and verification

---
 web-v2/src/pages/FindingDetailPage.tsx | 145 ++++++++++++++++++-------
 1 file changed, 104 insertions(+), 41 deletions(-)

diff --git a/web-v2/src/pages/FindingDetailPage.tsx b/web-v2/src/pages/FindingDetailPage.tsx
index 7d20d84..0a97a67 100644
--- a/web-v2/src/pages/FindingDetailPage.tsx
+++ b/web-v2/src/pages/FindingDetailPage.tsx
@@ -1,30 +1,26 @@
 import { useEffect, useState } from 'react';
+import type { FormEvent } from 'react';
 import { Link, useNavigate, useParams } from 'react-router';
 import { useAuth } from '../auth/AuthContext';
 import { Alert, LoadingBlock, errorMessage } from '../components/Feedback';
 import { Icon } from '../components/Icon';
-import { FindingOfficeWorkspace } from '../features/inspections/FindingOfficeWorkspace';
 import { InspectionEvidencePanel } from '../features/inspections/InspectionEvidencePanel';
-import { getInspectionFinding } from '../lib/api';
+import { closeInspectionFinding, getInspectionFinding } from '../lib/api';
 import type { InspectionFinding } from '../lib/api';
 import { formatDate, formatDateOnly } from '../lib/format';
 
-function todayInput(): string {
-  const now = new Date();
-  const local = new Date(now.getTime() - now.getTimezoneOffset() * 60_000);
-  return local.toISOString().slice(0, 10);
-}
-
 export function FindingDetailPage() {
   const { id } = useParams();
   const navigate = useNavigate();
   const { hasPermission } = useAuth();
   const [finding, setFinding] = useState<InspectionFinding | null>(null);
   const [loading, setLoading] = useState(true);
+  const [busy, setBusy] = useState(false);
   const [error, setError] = useState('');
+  const [success, setSuccess] = useState('');
+  const [closureNotes, setClosureNotes] = useState('');
   const [evidenceRefreshKey, setEvidenceRefreshKey] = useState(0);
 
-  const canFollowUp = hasPermission('inspection_findings.follow_up');
   const canClose = hasPermission('inspection_findings.close');
   const canReadEvidence = hasPermission('inspection_evidence.read');
   const canCreateEvidence = hasPermission('inspection_evidence.create');
@@ -41,14 +37,9 @@ export function FindingDetailPage() {
       .finally(() => setLoading(false));
   }, [id]);
 
-  if (loading) return <LoadingBlock label="Cargando hallazgo…" />;
+  if (loading) return <LoadingBlock label="Cargando Hallazgo…" />;
   if (!finding) return <section><Alert>{error || 'Hallazgo no encontrado'}</Alert></section>;
 
-  const responseOverdue = finding.status === 'OPEN'
-    && !finding.companyResponseReceivedOn
-    && Boolean(finding.correctionDueOn && finding.correctionDueOn < todayInput());
-  const verificationOverdue = finding.status === 'OPEN'
-    && Boolean(finding.companyResponseReceivedOn && finding.nextControlOn && finding.nextControlOn < todayInput());
   const latestVerification = finding.latestVerification;
   const verificationReadyToClose = latestVerification?.outcome === 'RESOLVED'
     && latestVerification.visitStatus === 'CLOSED';
@@ -60,48 +51,118 @@ export function FindingDetailPage() {
         ? 'Requiere nueva fecha'
         : 'Sin resultado';
 
+  const closeFinding = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!closureNotes.trim()) return;
+    setBusy(true); setError(''); setSuccess('');
+    try {
+      const updated = await closeInspectionFinding(finding.id, closureNotes.trim());
+      setFinding(updated);
+      setClosureNotes('');
+      setSuccess('Hallazgo cerrado. La conclusión quedó incorporada al historial sin modificar el Hallazgo original.');
+    } catch (requestError) {
+      setError(errorMessage(requestError));
+    } finally {
+      setBusy(false);
+    }
+  };
+
   return <section>
-    <div className="finding-detail-breadcrumb"><button type="button" className="text-link" onClick={() => navigate('/hallazgos')}>Hallazgos</button><span>›</span><strong>{finding.code}</strong></div>
+    <div className="finding-detail-breadcrumb">
+      <button type="button" className="text-link" onClick={() => navigate('/hallazgos')}>Hallazgos</button>
+      <span>›</span><strong>{finding.code}</strong>
+    </div>
+
     <div className="page-heading finding-detail-heading">
-      <div><span className="eyebrow">{finding.code}</span><h1>{finding.title}</h1><p>{finding.asset.operatorCompany?.name ?? 'Empresa sin asignar'} · {finding.asset.operationalArea?.name ?? 'Área sin asignar'}</p></div>
-      <span className={`status-badge large ${finding.status === 'OPEN' ? 'observed' : 'active'}`}>{finding.status === 'OPEN' ? 'Abierto' : 'Cerrado'}</span>
+      <div>
+        <span className="eyebrow">{finding.code}</span>
+        <h1>{finding.title}</h1>
+        <p>{finding.asset.operatorCompany?.name ?? 'Empresa sin asignar'} · {finding.asset.operationalArea?.name ?? 'Área sin asignar'}</p>
+      </div>
+      <span className={`status-badge large ${finding.status === 'OPEN' ? 'observed' : 'active'}`}>
+        {finding.status === 'OPEN' ? 'Abierto' : 'Cerrado'}
+      </span>
     </div>
 
     {error && <Alert>{error}</Alert>}
+    {success && <Alert type="success">{success}</Alert>}
+
+    <article className="panel">
+      <div className="panel-heading">
+        <div>
+          <span className="eyebrow">CONTENIDO ORIGINAL</span>
+          <h2>Descripción</h2>
+          <p className="section-copy">Texto libre registrado por el inspector. Una vez bloqueada el Acta, este contenido es inmutable.</p>
+        </div>
+      </div>
+      <p style={{ whiteSpace: 'pre-wrap' }}>{finding.description || 'Sin descripción registrada.'}</p>
+      {finding.legalBasis && <p><strong>Base legal / normativa:</strong> {finding.legalBasis}</p>}
+    </article>
 
     <div className="finding-detail-summary-grid">
-      <article><small>Elemento del inventario</small><Link to={`/inventarios/${finding.assetId}`}>{finding.asset.name}</Link><span>{finding.asset.code} · {finding.asset.typeName}</span></article>
-      <article><small>Acta / inspección</small><Link to={`/inspecciones/actas/${finding.actId}`}>{finding.document.actCode}</Link><span><Link className="text-link" to={`/inspecciones/${finding.document.visitId}`}>{finding.document.visitCode}</Link></span></article>
-      <article className={responseOverdue ? 'overdue' : ''}><small>Vencimiento administrativo</small><strong>{formatDateOnly(finding.correctionDueOn)}</strong><span>{finding.companyResponseReceivedOn ? `Respondido ${formatDateOnly(finding.companyResponseReceivedOn)}` : 'Esperando respuesta de empresa'}</span></article>
-      <article className={verificationOverdue ? 'overdue' : ''}><small>Fecha de verificación</small><strong>{formatDateOnly(finding.nextControlOn)}</strong><span>{finding.nextControlOn ? 'Planificación de inspección o control' : 'Todavía sin definir'}</span></article>
-      <article><small>Gravedad</small><strong>{finding.severity ? `${finding.severity}/10` : 'Sin calificar'}</strong><span>{finding.suggestedSeverity ? `Sugerida por catálogo: ${finding.suggestedSeverity}/10` : finding.catalogItemId ? 'El catálogo no define una sugerencia' : 'Hallazgo OTROS'}</span></article>
+      <article>
+        <small>Elemento del Inventario</small>
+        <Link to={`/inventarios/${finding.assetId}`}>{finding.asset.name}</Link>
+        <span>{finding.asset.code} · {finding.asset.typeName}</span>
+      </article>
+      <article>
+        <small>Acta / Inspección</small>
+        <Link to={`/inspecciones/actas/${finding.actId}`}>{finding.document.actCode}</Link>
+        <span><Link className="text-link" to={`/inspecciones/${finding.document.visitId}`}>{finding.document.visitCode}</Link></span>
+      </article>
+      <article>
+        <small>Gravedad</small>
+        <strong>{finding.severity ? `${finding.severity}/10` : 'Sin calificar'}</strong>
+        <span>{finding.suggestedSeverity ? `Sugerida por catálogo: ${finding.suggestedSeverity}/10` : finding.catalogItemId ? 'El catálogo no define una sugerencia' : 'Hallazgo OTROS'}</span>
+      </article>
+      <article>
+        <small>Reincidencia</small>
+        <strong>{finding.isRecurrence ? 'Sí' : 'No'}</strong>
+        <span>{finding.recurrenceOfFindingCode ? `Antecedente: ${finding.recurrenceOfFindingCode}` : finding.isRecurrence ? 'Antecedente vinculado' : 'Sin antecedente marcado'}</span>
+      </article>
+      <article>
+        <small>Próxima verificación</small>
+        <strong>{formatDateOnly(finding.nextControlOn)}</strong>
+        <span>{finding.verificationVisit ? `Planificada en ${finding.verificationVisit.code}` : finding.nextControlOn ? 'Pendiente de planificación' : 'Sin fecha definida'}</span>
+      </article>
     </div>
 
     {finding.verificationVisit && <article className="panel verification-linked-visit">
-      <div className="panel-heading"><div><span className="eyebrow">VERIFICACIÓN PLANIFICADA</span><h2>{finding.verificationVisit.code}</h2><p className="section-copy">Este hallazgo ya está incorporado a una visita de verificación.</p></div><Link className="button secondary" to={`/inspecciones/${finding.verificationVisit.id}`}>Abrir visita <Icon name="chevron" /></Link></div>
-      <div className="finding-two-deadlines"><div><span>FECHA OBJETIVO</span><strong>{formatDateOnly(finding.nextControlOn)}</strong><p>Fecha definida en el seguimiento del hallazgo.</p></div><div><span>VISITA</span><strong>{formatDate(finding.verificationVisit.plannedStartAt)}</strong><p>{finding.verificationVisit.code}</p></div></div>
+      <div className="panel-heading">
+        <div>
+          <span className="eyebrow">VERIFICACIÓN PLANIFICADA</span>
+          <h2>{finding.verificationVisit.code}</h2>
+          <p className="section-copy">Este Hallazgo está incorporado a una Inspección de verificación.</p>
+        </div>
+        <Link className="button secondary" to={`/inspecciones/${finding.verificationVisit.id}`}>Abrir Inspección <Icon name="chevron" /></Link>
+      </div>
+      <div className="finding-two-deadlines">
+        <div><span>FECHA OBJETIVO</span><strong>{formatDateOnly(finding.nextControlOn)}</strong><p>Fecha técnica de control del Hallazgo.</p></div>
+        <div><span>INSPECCIÓN</span><strong>{formatDate(finding.verificationVisit.plannedStartAt)}</strong><p>{finding.verificationVisit.code}</p></div>
+      </div>
     </article>}
 
     {latestVerification?.outcome && <article className={`panel verification-result-panel ${latestVerification.outcome === 'RESOLVED' ? 'resolved' : ''}`}>
-      <div className="panel-heading"><div><span className="eyebrow">ÚLTIMA VERIFICACIÓN DE CAMPO</span><h2>{verificationOutcomeLabel}</h2><p className="section-copy">Resultado registrado por el inspector durante {latestVerification.visitCode}.</p></div><Link className="button secondary" to={`/inspecciones/${latestVerification.visitId}`}>Abrir verificación <Icon name="chevron" /></Link></div>
+      <div className="panel-heading">
+        <div><span className="eyebrow">ÚLTIMA VERIFICACIÓN DE CAMPO</span><h2>{verificationOutcomeLabel}</h2><p className="section-copy">Resultado registrado durante {latestVerification.visitCode}.</p></div>
+        <Link className="button secondary" to={`/inspecciones/${latestVerification.visitId}`}>Abrir verificación <Icon name="chevron" /></Link>
+      </div>
       <div className="finding-two-deadlines">
         <div><span>RESULTADO</span><strong>{verificationOutcomeLabel}</strong><p>{latestVerification.resultNotes || 'Sin observaciones adicionales.'}</p></div>
-        <div><span>VERIFICADO</span><strong>{formatDate(latestVerification.verifiedAt)}</strong><p>{latestVerification.evidenceCount} foto{latestVerification.evidenceCount === 1 ? '' : 's'} de verificación.</p></div>
-        {latestVerification.rescheduledControlOn && <div><span>NUEVA FECHA</span><strong>{formatDateOnly(latestVerification.rescheduledControlOn)}</strong><p>El hallazgo vuelve a la planificación operativa.</p></div>}
+        <div><span>VERIFICADO</span><strong>{formatDate(latestVerification.verifiedAt)}</strong><p>{latestVerification.evidenceCount} evidencia{latestVerification.evidenceCount === 1 ? '' : 's'} de verificación.</p></div>
+        {latestVerification.rescheduledControlOn && <div><span>NUEVA FECHA</span><strong>{formatDateOnly(latestVerification.rescheduledControlOn)}</strong><p>El Hallazgo vuelve a planificación de control.</p></div>}
       </div>
-      {verificationReadyToClose && finding.status === 'OPEN' && <Alert type="success">La verificación de campo indicó que el hallazgo está solucionado y quedó listo para revisión de oficina.</Alert>}
-      {latestVerification.outcome === 'NOT_RESOLVED' && finding.status === 'OPEN' && <Alert>La verificación indicó que el hallazgo continúa abierto. Debe definirse una nueva fecha de control.</Alert>}
+      {verificationReadyToClose && finding.status === 'OPEN' && <Alert type="success">La verificación indicó que el Hallazgo está solucionado y quedó listo para cierre técnico.</Alert>}
+      {latestVerification.outcome === 'NOT_RESOLVED' && finding.status === 'OPEN' && <Alert>La verificación indicó que el Hallazgo continúa abierto.</Alert>}
     </article>}
 
-    <FindingOfficeWorkspace
-      finding={finding}
-      canFollowUp={canFollowUp}
-      canClose={canClose}
-      canCreateEvidence={canCreateEvidence}
-      canCreateCommunications={canCreateCommunications}
-      onFindingChanged={setFinding}
-      onEvidenceChanged={() => setEvidenceRefreshKey((value) => value + 1)}
-    />
+    {verificationReadyToClose && finding.status === 'OPEN' && canClose && <article className="panel" id="cierre-hallazgo">
+      <div className="panel-heading"><div><span className="eyebrow">CIERRE TÉCNICO</span><h2>Cerrar Hallazgo</h2><p className="section-copy">El cierre agrega una conclusión al historial; nunca modifica la descripción original.</p></div></div>
+      <form onSubmit={closeFinding}>
+        <label className="field"><span>Conclusión de cierre</span><textarea value={closureNotes} onChange={(event) => setClosureNotes(event.target.value)} required minLength={3} rows={4} /></label>
+        <div className="form-actions"><button className="button primary" disabled={busy || !closureNotes.trim()}>{busy ? 'Cerrando…' : 'Cerrar Hallazgo'}</button></div>
+      </form>
+    </article>}
 
     <div id="documentos-hallazgo">
       <InspectionEvidencePanel
@@ -112,10 +173,12 @@ export function FindingDetailPage() {
         canReadCommunications={canReadCommunications}
         canCreateCommunications={canCreateCommunications}
         refreshKey={evidenceRefreshKey}
-        managedCompanyResponse
       />
     </div>
 
-    {finding.status === 'CLOSED' && <article className="closed-seal finding-closed-seal"><Icon name="check" /><div><span className="eyebrow">HALLAZGO CERRADO</span><strong>{formatDate(finding.closedAt)}</strong><p>{finding.closureNotes}</p></div></article>}
+    {finding.status === 'CLOSED' && <article className="closed-seal finding-closed-seal">
+      <Icon name="check" />
+      <div><span className="eyebrow">HALLAZGO CERRADO</span><strong>{formatDate(finding.closedAt)}</strong><p>{finding.closureNotes}</p></div>
+    </article>}
   </section>;
 }

From f8e866a140c9607051f95d5da53fcf476cd2175f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:41:32 -0300
Subject: [PATCH 081/224] F4: add inventory function change panel

---
 .../assets/InventoryFunctionPanel.tsx         | 160 ++++++++++++++++++
 1 file changed, 160 insertions(+)
 create mode 100644 web-v2/src/features/assets/InventoryFunctionPanel.tsx

diff --git a/web-v2/src/features/assets/InventoryFunctionPanel.tsx b/web-v2/src/features/assets/InventoryFunctionPanel.tsx
new file mode 100644
index 0000000..73a48af
--- /dev/null
+++ b/web-v2/src/features/assets/InventoryFunctionPanel.tsx
@@ -0,0 +1,160 @@
+import { useEffect, useState } from 'react';
+import type { FormEvent } from 'react';
+import { Link } from 'react-router';
+import { useAuth } from '../../auth/AuthContext';
+import { Alert, LoadingBlock, errorMessage } from '../../components/Feedback';
+import { SearchableSelect } from '../../components/SearchableSelect';
+import { formatDate } from '../../lib/format';
+import {
+  changeInventoryFunction,
+  getInventoryFunctionHistory,
+  listInventoryFunctions,
+} from '../../lib/inventoryFunctionApi';
+import type {
+  InventoryFunction,
+  InventoryFunctionHistory,
+} from '../../lib/inventoryFunctionApi';
+
+function localDateTime(value: Date): string {
+  const local = new Date(value.getTime() - value.getTimezoneOffset() * 60_000);
+  return local.toISOString().slice(0, 16);
+}
+
+export function InventoryFunctionPanel({ assetId }: { assetId: string }) {
+  const { hasPermission } = useAuth();
+  const canChange = hasPermission('assets.update');
+  const canManageCatalog = hasPermission('asset_types.manage');
+  const [catalog, setCatalog] = useState<InventoryFunction[]>([]);
+  const [history, setHistory] = useState<InventoryFunctionHistory | null>(null);
+  const [functionId, setFunctionId] = useState('');
+  const [effectiveAt, setEffectiveAt] = useState('');
+  const [reason, setReason] = useState('');
+  const [loading, setLoading] = useState(true);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState('');
+  const [success, setSuccess] = useState('');
+
+  const load = () => {
+    setLoading(true);
+    setError('');
+    Promise.all([
+      listInventoryFunctions(),
+      getInventoryFunctionHistory(assetId),
+    ])
+      .then(([loadedCatalog, loadedHistory]) => {
+        setCatalog(loadedCatalog);
+        setHistory(loadedHistory);
+        setFunctionId(loadedHistory.currentFunction?.functionId ?? '');
+      })
+      .catch((requestError) => setError(errorMessage(requestError)))
+      .finally(() => setLoading(false));
+  };
+
+  useEffect(() => { load(); }, [assetId]);
+
+  const submit = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!functionId || functionId === history?.currentFunction?.functionId) return;
+    setBusy(true);
+    setError('');
+    setSuccess('');
+    try {
+      const updated = await changeInventoryFunction(assetId, {
+        functionId,
+        effectiveAt: effectiveAt ? new Date(effectiveAt).toISOString() : undefined,
+        reason: reason.trim() || null,
+      });
+      setHistory(updated);
+      setFunctionId(updated.currentFunction?.functionId ?? '');
+      setEffectiveAt('');
+      setReason('');
+      setSuccess('Cambio de función registrado. La función anterior permanece en el historial del Inventario.');
+    } catch (requestError) {
+      setError(errorMessage(requestError));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  if (loading) return <article className="panel"><LoadingBlock label="Cargando función operativa…" /></article>;
+  if (!history) return <Alert>{error || 'No se pudo cargar la función operativa.'}</Alert>;
+
+  const current = history.currentFunction;
+
+  return <article className="panel">
+    <div className="panel-heading">
+      <div>
+        <span className="eyebrow">FUNCIÓN OPERATIVA</span>
+        <h2>Función de la Estación / Subestación</h2>
+        <p className="section-copy">La identidad del Inventario no cambia. Cada mutación de función conserva fecha, usuario y antecedente para la consulta histórica.</p>
+      </div>
+      {canManageCatalog && <Link className="button secondary" to="/admin/inventory-functions">Administrar catálogo</Link>}
+    </div>
+
+    {error && <Alert>{error}</Alert>}
+    {success && <Alert type="success">{success}</Alert>}
+
+    <div className="finding-detail-summary-grid">
+      <div>
+        <small>Función vigente</small>
+        <strong>{current?.functionName ?? 'Sin función asignada'}</strong>
+        <span>{current ? `${current.functionCode} · desde ${formatDate(current.validFrom)}` : 'Debe seleccionarse una función del catálogo.'}</span>
+      </div>
+      <div>
+        <small>Cambios registrados</small>
+        <strong>{history.history.length}</strong>
+        <span>Historial temporal del mismo Inventario.</span>
+      </div>
+    </div>
+
+    {canChange && <form className="form-section" onSubmit={submit}>
+      <div>
+        <h3>Cambiar función</h3>
+        <p className="section-copy">Ejemplo: Bombeo Mecánico AIB → Bombeo Mecánico Rotaflex. No se crea una Estación nueva.</p>
+      </div>
+      <div className="form-grid">
+        <label className="field">
+          <span>Nueva función</span>
+          <SearchableSelect value={functionId} onChange={(event) => setFunctionId(event.target.value)} required>
+            <option value="">Seleccionar función…</option>
+            {catalog.map((item) => <option key={item.id} value={item.id}>{item.name} · {item.code}</option>)}
+          </SearchableSelect>
+        </label>
+        <label className="field">
+          <span>Fecha efectiva <em>opcional</em></span>
+          <input
+            type="datetime-local"
+            value={effectiveAt}
+            max={localDateTime(new Date())}
+            onChange={(event) => setEffectiveAt(event.target.value)}
+          />
+          <small>Si queda vacía, se toma el momento actual.</small>
+        </label>
+      </div>
+      <label className="field">
+        <span>Motivo / observación <em>opcional</em></span>
+        <textarea rows={2} maxLength={4000} value={reason} onChange={(event) => setReason(event.target.value)} placeholder="Ej.: conversión del sistema de bombeo durante intervención de septiembre…" />
+      </label>
+      <div className="form-actions">
+        <button className="button primary" disabled={busy || !functionId || functionId === current?.functionId}>
+          {busy ? 'Registrando…' : 'Registrar cambio de función'}
+        </button>
+      </div>
+    </form>}
+
+    <div className="form-section">
+      <div><h3>Historial de funciones</h3><p className="section-copy">La función anterior nunca se sobrescribe ni se elimina.</p></div>
+      {history.history.length === 0
+        ? <div className="inline-empty">Todavía no hay funciones registradas para este Inventario.</div>
+        : <div className="dossier-link-list">
+          {history.history.map((item) => <div key={item.id}>
+            <div>
+              <strong>{item.functionName}</strong>
+              <small>{item.functionCode}{item.reason ? ` · ${item.reason}` : ''}</small>
+            </div>
+            <span>{formatDate(item.validFrom)} → {item.validUntil ? formatDate(item.validUntil) : 'actual'}{item.changedByUsername ? ` · ${item.changedByUsername}` : ''}</span>
+          </div>)}
+        </div>}
+    </div>
+  </article>;
+}

From 86e692c537427a9738ad48b8b55862240bd8aec4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:41:59 -0300
Subject: [PATCH 082/224] F4: add inventory function catalog admin

---
 web-v2/src/pages/InventoryFunctionsPage.tsx | 166 ++++++++++++++++++++
 1 file changed, 166 insertions(+)
 create mode 100644 web-v2/src/pages/InventoryFunctionsPage.tsx

diff --git a/web-v2/src/pages/InventoryFunctionsPage.tsx b/web-v2/src/pages/InventoryFunctionsPage.tsx
new file mode 100644
index 0000000..2376953
--- /dev/null
+++ b/web-v2/src/pages/InventoryFunctionsPage.tsx
@@ -0,0 +1,166 @@
+import { useEffect, useState } from 'react';
+import type { FormEvent } from 'react';
+import { Alert, LoadingBlock, errorMessage } from '../components/Feedback';
+import {
+  createInventoryFunction,
+  listInventoryFunctions,
+  updateInventoryFunction,
+} from '../lib/inventoryFunctionApi';
+import type { InventoryFunction } from '../lib/inventoryFunctionApi';
+
+export function InventoryFunctionsPage() {
+  const [items, setItems] = useState<InventoryFunction[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState('');
+  const [success, setSuccess] = useState('');
+  const [code, setCode] = useState('');
+  const [name, setName] = useState('');
+  const [description, setDescription] = useState('');
+  const [sortOrder, setSortOrder] = useState('0');
+  const [editingId, setEditingId] = useState<string | null>(null);
+  const [editName, setEditName] = useState('');
+  const [editDescription, setEditDescription] = useState('');
+  const [editSortOrder, setEditSortOrder] = useState('0');
+
+  const load = () => {
+    setLoading(true);
+    setError('');
+    listInventoryFunctions(true)
+      .then(setItems)
+      .catch((requestError) => setError(errorMessage(requestError)))
+      .finally(() => setLoading(false));
+  };
+
+  useEffect(() => { load(); }, []);
+
+  const create = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!code.trim() || !name.trim()) return;
+    setBusy(true);
+    setError('');
+    setSuccess('');
+    try {
+      await createInventoryFunction({
+        code,
+        name,
+        description: description.trim() || null,
+        sortOrder: Number(sortOrder || 0),
+      });
+      setCode('');
+      setName('');
+      setDescription('');
+      setSortOrder('0');
+      setSuccess('Función incorporada al catálogo. Ya puede asignarse a Estaciones y Subestaciones.');
+      load();
+    } catch (requestError) {
+      setError(errorMessage(requestError));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const beginEdit = (item: InventoryFunction) => {
+    setEditingId(item.id);
+    setEditName(item.name);
+    setEditDescription(item.description ?? '');
+    setEditSortOrder(String(item.sortOrder));
+    setError('');
+    setSuccess('');
+  };
+
+  const saveEdit = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!editingId || !editName.trim()) return;
+    setBusy(true);
+    setError('');
+    setSuccess('');
+    try {
+      await updateInventoryFunction(editingId, {
+        name: editName,
+        description: editDescription.trim() || null,
+        sortOrder: Number(editSortOrder || 0),
+      });
+      setEditingId(null);
+      setSuccess('Función actualizada. Los registros históricos conservan la referencia temporal correspondiente.');
+      load();
+    } catch (requestError) {
+      setError(errorMessage(requestError));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const toggleActive = async (item: InventoryFunction) => {
+    setBusy(true);
+    setError('');
+    setSuccess('');
+    try {
+      await updateInventoryFunction(item.id, { isActive: !item.isActive });
+      setSuccess(item.isActive
+        ? 'Función desactivada. No podrá elegirse en nuevos cambios, pero permanece en el historial.'
+        : 'Función reactivada y disponible nuevamente para asignación.');
+      load();
+    } catch (requestError) {
+      setError(errorMessage(requestError));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  if (loading) return <LoadingBlock label="Cargando catálogo de funciones…" />;
+
+  return <section className="narrow-section">
+    <div className="page-heading">
+      <div><span className="eyebrow">ADMINISTRACIÓN</span><h1>Catálogo de funciones</h1><p>Funciones operativas que pueden asumir las Estaciones y Subestaciones. Desactivar una opción nunca borra su uso histórico.</p></div>
+    </div>
+
+    {error && <Alert>{error}</Alert>}
+    {success && <Alert type="success">{success}</Alert>}
+
+    <form className="panel form-panel" onSubmit={create}>
+      <div className="form-section">
+        <div><h2>Nueva función</h2><p className="section-copy">Ejemplos: Bombeo Mecánico AIB, Bombeo Mecánico Rotaflex, PCP.</p></div>
+        <div className="form-grid">
+          <label className="field"><span>Código</span><input value={code} onChange={(event) => setCode(event.target.value.toUpperCase())} required maxLength={120} placeholder="BOMBEO_AIB" /></label>
+          <label className="field"><span>Nombre</span><input value={name} onChange={(event) => setName(event.target.value)} required maxLength={240} placeholder="Bombeo Mecánico AIB" /></label>
+          <label className="field"><span>Orden</span><input type="number" min={0} max={100000} value={sortOrder} onChange={(event) => setSortOrder(event.target.value)} /></label>
+        </div>
+        <label className="field"><span>Descripción <em>opcional</em></span><textarea rows={2} maxLength={4000} value={description} onChange={(event) => setDescription(event.target.value)} /></label>
+        <div className="form-actions"><button className="button primary" disabled={busy}>{busy ? 'Guardando…' : 'Agregar función'}</button></div>
+      </div>
+    </form>
+
+    <article className="panel">
+      <div className="panel-heading"><div><span className="eyebrow">CATÁLOGO</span><h2>Funciones disponibles</h2></div><span className="count-pill">{items.length}</span></div>
+      {items.length === 0 ? <div className="inline-empty">Todavía no hay funciones configuradas.</div> : <div className="dossier-link-list">
+        {items.map((item) => <div key={item.id}>
+          <div>
+            <strong>{item.name}</strong>
+            <small>{item.code}{item.description ? ` · ${item.description}` : ''}</small>
+          </div>
+          <span>{item.isActive ? 'Activa' : 'Inactiva'} · orden {item.sortOrder}</span>
+          <div className="form-actions">
+            <button type="button" className="button secondary" disabled={busy} onClick={() => beginEdit(item)}>Editar</button>
+            <button type="button" className="button secondary" disabled={busy} onClick={() => toggleActive(item)}>{item.isActive ? 'Desactivar' : 'Reactivar'}</button>
+          </div>
+        </div>)}
+      </div>}
+    </article>
+
+    {editingId && <form className="panel form-panel" onSubmit={saveEdit}>
+      <div className="form-section">
+        <div><h2>Editar función</h2><p className="section-copy">El código técnico permanece estable; podés corregir nombre, descripción y orden.</p></div>
+        <div className="form-grid">
+          <label className="field"><span>Nombre</span><input value={editName} onChange={(event) => setEditName(event.target.value)} required maxLength={240} /></label>
+          <label className="field"><span>Orden</span><input type="number" min={0} max={100000} value={editSortOrder} onChange={(event) => setEditSortOrder(event.target.value)} /></label>
+        </div>
+        <label className="field"><span>Descripción</span><textarea rows={2} maxLength={4000} value={editDescription} onChange={(event) => setEditDescription(event.target.value)} /></label>
+        <div className="form-actions">
+          <button type="button" className="button secondary" onClick={() => setEditingId(null)}>Cancelar</button>
+          <button className="button primary" disabled={busy}>{busy ? 'Guardando…' : 'Guardar cambios'}</button>
+        </div>
+      </div>
+    </form>}
+  </section>;
+}

From 4a86dd15d980c376762465b231f6b5cf1d47231e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:43:25 -0300
Subject: [PATCH 083/224] F4: expose function changes in inventory history

---
 .../src/features/assets/AssetHistoryPanel.tsx | 44 ++++++++++++++-----
 1 file changed, 34 insertions(+), 10 deletions(-)

diff --git a/web-v2/src/features/assets/AssetHistoryPanel.tsx b/web-v2/src/features/assets/AssetHistoryPanel.tsx
index c3096ab..99be492 100644
--- a/web-v2/src/features/assets/AssetHistoryPanel.tsx
+++ b/web-v2/src/features/assets/AssetHistoryPanel.tsx
@@ -2,6 +2,7 @@ import { useEffect, useState } from 'react';
 import { Alert, LoadingBlock, errorMessage } from '../../components/Feedback';
 import { Icon } from '../../components/Icon';
 import {
+  getAsset,
   getAssetVersion,
   listAssetVersionTimeline,
 } from '../../lib/api';
@@ -11,11 +12,26 @@ import type {
 } from '../../lib/api';
 import { formatDate } from '../../lib/format';
 import { AssetVersionDrawer } from './AssetVersionDrawer';
+import { InventoryFunctionPanel } from './InventoryFunctionPanel';
 import {
   assetVersionChangeLabel,
   assetVersionFieldLabel,
 } from './assetVersionPresentation';
 
+function normalized(value: string): string {
+  return value
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+}
+
+function supportsFunctionChange(code: string, name: string): boolean {
+  const value = `${normalized(code)} ${normalized(name)}`;
+  return value.split(' ').some((part) => part === 'estacion' || part === 'subestacion');
+}
+
 export function AssetHistoryPanel({
   assetId,
   refreshKey,
@@ -29,14 +45,19 @@ export function AssetHistoryPanel({
   const [error, setError] = useState('');
   const [detail, setDetail] = useState<AssetVersionDetail | null>(null);
   const [detailLoading, setDetailLoading] = useState(false);
+  const [functionEligible, setFunctionEligible] = useState(false);
 
   useEffect(() => {
     setLoading(true);
     setError('');
-    listAssetVersionTimeline(assetId, { pageSize: 10 })
-      .then((response) => {
+    Promise.all([
+      listAssetVersionTimeline(assetId, { pageSize: 10 }),
+      getAsset(assetId),
+    ])
+      .then(([response, asset]) => {
         setVersions(response.data);
         setTotal(response.meta.total);
+        setFunctionEligible(supportsFunctionChange(asset.type.code, asset.type.name));
       })
       .catch((requestError) => setError(errorMessage(requestError)))
       .finally(() => setLoading(false));
@@ -55,12 +76,15 @@ export function AssetHistoryPanel({
     }
   };
 
-  return <article className="panel asset-history-panel">
-    <div className="panel-heading"><div><span className="eyebrow">TRAZABILIDAD TEMPORAL</span><h2>Historial del registro</h2></div><span className="count-pill">{total} versión{total === 1 ? '' : 'es'}</span></div>
-    <p className="section-copy">Cada cambio conserva una copia completa e inmutable del registro, sus atributos y su ubicación.</p>
-    {error && <Alert>{error}</Alert>}
-    {loading ? <LoadingBlock label="Cargando historial…" /> : <div className="asset-timeline">{versions.map((version) => <button type="button" className="timeline-entry" key={version.id} onClick={() => open(version)}><span className={`timeline-dot ${version.isCurrent ? 'current' : ''}`} /><span><strong>v{version.versionNumber} · {assetVersionChangeLabel(version.changeType)}</strong><small>{formatDate(version.occurredAt)} · {version.actorUsername ?? 'Sistema'}</small><span className="tag-list">{version.changedFields.slice(0, 4).map((field) => <em className="tag" key={field}>{assetVersionFieldLabel(field)}</em>)}</span></span><Icon name="chevron" size={16} /></button>)}</div>}
-    {!loading && total > versions.length && <p className="history-limit-note">Se muestran las 10 versiones más recientes. El historial completo está disponible en la sección Historial.</p>}
-    {(detailLoading || detail) && <AssetVersionDrawer detail={detail} loading={detailLoading} onClose={() => setDetail(null)} />}
-  </article>;
+  return <div className="asset-tab-stack">
+    {functionEligible && <InventoryFunctionPanel assetId={assetId} />}
+    <article className="panel asset-history-panel">
+      <div className="panel-heading"><div><span className="eyebrow">TRAZABILIDAD TEMPORAL</span><h2>Historial del registro</h2></div><span className="count-pill">{total} versión{total === 1 ? '' : 'es'}</span></div>
+      <p className="section-copy">Cada cambio conserva una copia completa e inmutable del registro, sus atributos, su ubicación y, cuando corresponde, su función operativa.</p>
+      {error && <Alert>{error}</Alert>}
+      {loading ? <LoadingBlock label="Cargando historial…" /> : <div className="asset-timeline">{versions.map((version) => <button type="button" className="timeline-entry" key={version.id} onClick={() => open(version)}><span className={`timeline-dot ${version.isCurrent ? 'current' : ''}`} /><span><strong>v{version.versionNumber} · {assetVersionChangeLabel(version.changeType)}</strong><small>{formatDate(version.occurredAt)} · {version.actorUsername ?? 'Sistema'}</small><span className="tag-list">{version.changedFields.slice(0, 4).map((field) => <em className="tag" key={field}>{assetVersionFieldLabel(field)}</em>)}</span></span><Icon name="chevron" size={16} /></button>)}</div>}
+      {!loading && total > versions.length && <p className="history-limit-note">Se muestran las 10 versiones más recientes. El historial completo está disponible en la sección Historial.</p>}
+      {(detailLoading || detail) && <AssetVersionDrawer detail={detail} loading={detailLoading} onClose={() => setDetail(null)} />}
+    </article>
+  </div>;
 }

From 558fdbc85d2c0265210caf537e50e09b12a6af37 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:43:43 -0300
Subject: [PATCH 084/224] F4: route inventory function catalog admin

---
 web-v2/src/app/App.tsx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/web-v2/src/app/App.tsx b/web-v2/src/app/App.tsx
index 7a16317..79531b0 100644
--- a/web-v2/src/app/App.tsx
+++ b/web-v2/src/app/App.tsx
@@ -18,6 +18,7 @@ import { AssetEditorPage } from '../pages/AssetEditorPage';
 import { InventoryCreatePage } from '../pages/InventoryCreatePage';
 import { FieldDiscoveriesPage } from '../pages/FieldDiscoveriesPage';
 import { AssetTypesPage } from '../pages/AssetTypesPage';
+import { InventoryFunctionsPage } from '../pages/InventoryFunctionsPage';
 import { HistoryPage } from '../pages/HistoryPage';
 import { TemporalAssetsPage } from '../pages/TemporalAssetsPage';
 import { InspectionVisitsPage } from '../pages/InspectionVisitsPage';
@@ -83,6 +84,7 @@ export function App() {
         <Route element={<PermissionRoute permission="roles.read" />}><Route path="/admin/roles" element={<RolesPage />} /></Route>
         <Route element={<PermissionRoute permission="audit.read" />}><Route path="/admin/audit" element={<AuditPage />} /></Route>
         <Route element={<PermissionRoute permission="asset_types.read" />}><Route path="/admin/asset-types" element={<AssetTypesPage />} /></Route>
+        <Route element={<PermissionRoute permission="asset_types.manage" />}><Route path="/admin/inventory-functions" element={<InventoryFunctionsPage />} /></Route>
         <Route element={<PermissionRoute permission="finding_catalog.manage" />}><Route path="/admin/finding-catalog" element={<FindingCatalogPage />} /></Route>
         <Route element={<PermissionRoute permission="document_delivery.read" />}><Route path="/admin/document-delivery" element={<DocumentDeliveryPage />} /></Route>
         <Route path="/sin-acceso" element={<AccessDeniedPage />} />

From fb12ce3cff185842955c1ba337f4630e85fb93e1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:44:00 -0300
Subject: [PATCH 085/224] F4: add function catalog to administration navigation

---
 web-v2/src/layout/AppLayout.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/web-v2/src/layout/AppLayout.tsx b/web-v2/src/layout/AppLayout.tsx
index dd5c1c7..3511e6a 100644
--- a/web-v2/src/layout/AppLayout.tsx
+++ b/web-v2/src/layout/AppLayout.tsx
@@ -39,6 +39,7 @@ const administration: NavItem[] = [
   { to: '/admin/users', label: 'Usuarios', icon: 'users', permission: 'users.read' },
   { to: '/admin/roles', label: 'Roles y permisos', icon: 'shield', permission: 'roles.read' },
   { to: '/admin/asset-types', label: 'Configuración de Inventarios', icon: 'layers', permission: 'asset_types.read' },
+  { to: '/admin/inventory-functions', label: 'Catálogo de funciones', icon: 'history', permission: 'asset_types.manage' },
   { to: '/admin/finding-catalog', label: 'Catálogo de hallazgos', icon: 'alert', permission: 'finding_catalog.manage' },
   { to: '/admin/document-delivery', label: 'Entrega documental', icon: 'audit', permission: 'document_delivery.read' },
 ];

From 513fe6121b7b4b6fa5efc0836d33e814fcdb5688 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:45:57 -0300
Subject: [PATCH 086/224] F4: add web client for report workflow

---
 web-v2/src/lib/reportWorkflowApi.ts | 143 ++++++++++++++++++++++++++++
 1 file changed, 143 insertions(+)
 create mode 100644 web-v2/src/lib/reportWorkflowApi.ts

diff --git a/web-v2/src/lib/reportWorkflowApi.ts b/web-v2/src/lib/reportWorkflowApi.ts
new file mode 100644
index 0000000..03942f4
--- /dev/null
+++ b/web-v2/src/lib/reportWorkflowApi.ts
@@ -0,0 +1,143 @@
+import { apiRequest } from './api';
+
+export type InspectionReportStatus = 'WORKING' | 'OFFICIALIZED' | 'FROZEN' | 'CANCELLED';
+export type InspectionReportFollowUpType =
+  | 'COMPANY_NOTE'
+  | 'COMPANY_DOCUMENT'
+  | 'INTERNAL_NOTE'
+  | 'VERIFICATION'
+  | 'OTHER';
+
+export interface InspectionReportDetailF4 {
+  id: string;
+  visitId: string;
+  actId: string;
+  reportYear: number;
+  reportNumber: number;
+  code: string;
+  status: InspectionReportStatus;
+  executiveSummary: string | null;
+  reportDescription: string | null;
+  gedoIfIdentifier: string | null;
+  gedoOfficializedAt: string | null;
+  gedoPdfOriginalName: string | null;
+  gedoPdfSha256: string | null;
+  pdfStatus: 'PENDING' | 'READY' | 'FAILED';
+  wordStatus: 'PENDING' | 'READY' | 'FAILED';
+  wordGeneratedAt: string | null;
+  title: string;
+  actVersion: number;
+  actClosureSha256: string;
+  frozenSha256: string;
+  generatedAt: string;
+  generatedBy: { id: string; username: string; firstName: string; lastName: string };
+  act: {
+    id: string;
+    code: string;
+    title: string;
+    status: string;
+    occurredAt: string;
+    sealedAt: string | null;
+    urgency: string;
+    deadlineAt: string | null;
+  };
+  visit: { id: string; code: string; title: string; status: string };
+  companies: Array<{ id: string; code: string; name: string }>;
+  areas: Array<{ id: string; code: string; name: string }>;
+  findingCount: number;
+}
+
+export interface InspectionReportFollowUp {
+  id: string;
+  reportId: string;
+  type: InspectionReportFollowUpType;
+  externalReference: string | null;
+  occurredAt: string;
+  description: string | null;
+  originalName: string | null;
+  mimeType: string | null;
+  sizeBytes: number | null;
+  sha256: string | null;
+  createdBy: string | null;
+  createdAt: string;
+}
+
+export interface InspectionReportWorkflowView {
+  id: string;
+  actId: string;
+  visitId: string;
+  code: string;
+  status: InspectionReportStatus;
+  executiveSummary: string | null;
+  reportDescription: string | null;
+  gedoIfIdentifier: string | null;
+  gedoOfficializedAt: string | null;
+  act: {
+    code: string;
+    urgency: string;
+    deadlineDays: number | null;
+    deadlineDayType: 'BUSINESS' | 'CALENDAR' | null;
+    deadlineBasis: string | null;
+    deadlineBaseAt: string | null;
+    deadlineAt: string | null;
+  } | null;
+  followUps: InspectionReportFollowUp[];
+}
+
+export function getInspectionReportF4(id: string) {
+  return apiRequest<InspectionReportDetailF4>(`/inspection-reports/${id}`);
+}
+
+export function listInspectionReportFollowUps(id: string) {
+  return apiRequest<InspectionReportFollowUp[]>(`/inspection-reports/${id}/follow-ups`);
+}
+
+export function updateInspectionReportNarrative(
+  id: string,
+  input: { executiveSummary?: string | null; description?: string | null },
+) {
+  return apiRequest<InspectionReportWorkflowView>(`/inspection-reports/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export function officializeInspectionReport(
+  id: string,
+  input: { gedoIfIdentifier: string; gedoOfficializedAt: string; file: File },
+) {
+  const body = new FormData();
+  body.set('gedoIfIdentifier', input.gedoIfIdentifier);
+  body.set('gedoOfficializedAt', input.gedoOfficializedAt);
+  body.set('file', input.file);
+  return apiRequest<InspectionReportWorkflowView>(`/inspection-reports/${id}/officialize`, {
+    method: 'POST',
+    body,
+  });
+}
+
+export function addInspectionReportFollowUp(
+  id: string,
+  input: {
+    type: InspectionReportFollowUpType;
+    occurredAt: string;
+    externalReference?: string | null;
+    description?: string | null;
+    file?: File | null;
+  },
+) {
+  const body = new FormData();
+  body.set('type', input.type);
+  body.set('occurredAt', input.occurredAt);
+  if (input.externalReference?.trim()) body.set('externalReference', input.externalReference.trim());
+  if (input.description?.trim()) body.set('description', input.description.trim());
+  if (input.file) body.set('file', input.file);
+  return apiRequest<InspectionReportFollowUp[]>(`/inspection-reports/${id}/follow-ups`, {
+    method: 'POST',
+    body,
+  });
+}
+
+export function inspectionReportWordDownloadUrl(id: string) {
+  return `/api/v3/inspection-reports/${id}/word`;
+}

From f83ab824ff1284c4775c611fb666dfc464db4304 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:46:53 -0300
Subject: [PATCH 087/224] F4: replace director report review UI with INF
 workflow

---
 web-v2/src/pages/ReportDetailPage.tsx | 267 ++++++++++++++++----------
 1 file changed, 170 insertions(+), 97 deletions(-)

diff --git a/web-v2/src/pages/ReportDetailPage.tsx b/web-v2/src/pages/ReportDetailPage.tsx
index 2d4b7a3..107c8e1 100644
--- a/web-v2/src/pages/ReportDetailPage.tsx
+++ b/web-v2/src/pages/ReportDetailPage.tsx
@@ -4,60 +4,97 @@ import { Link, useParams } from 'react-router';
 import { useAuth } from '../auth/AuthContext';
 import { Alert, LoadingBlock, errorMessage } from '../components/Feedback';
 import { Icon } from '../components/Icon';
-import {
-  approveInspectionReport,
-  getInspectionReport,
-  getInspectionReportReview,
-  inspectionReportRevisionUrl,
-  inspectionReportWordUrl,
-  signFinalInspectionReport,
-  uploadInspectionReportRevision,
-} from '../lib/api';
-import type { InspectionReport, InspectionReportReview } from '../lib/api';
+import { SearchableSelect } from '../components/SearchableSelect';
 import { formatDate } from '../lib/format';
+import {
+  addInspectionReportFollowUp,
+  getInspectionReportF4,
+  inspectionReportWordDownloadUrl,
+  listInspectionReportFollowUps,
+  officializeInspectionReport,
+  updateInspectionReportNarrative,
+} from '../lib/reportWorkflowApi';
+import type {
+  InspectionReportDetailF4,
+  InspectionReportFollowUp,
+  InspectionReportFollowUpType,
+} from '../lib/reportWorkflowApi';
 
 function names(items: Array<{ name: string }>, empty: string): string {
   return items.length ? items.map((item) => item.name).join(' · ') : empty;
 }
 
-function reviewLabel(value: InspectionReport['reviewStatus']): string {
-  if (value === 'SIGNED') return 'Firmado';
-  if (value === 'APPROVED') return 'Aprobado · falta firma';
-  return 'Pendiente de revisión';
+function localDateTime(value: Date): string {
+  const local = new Date(value.getTime() - value.getTimezoneOffset() * 60_000);
+  return local.toISOString().slice(0, 16);
 }
 
-function reviewClass(value: InspectionReport['reviewStatus']): string {
-  if (value === 'SIGNED') return 'active';
-  if (value === 'APPROVED') return 'observed';
+function reportStatusLabel(status: InspectionReportDetailF4['status']): string {
+  if (status === 'WORKING') return 'En preparación';
+  if (status === 'OFFICIALIZED') return 'Oficializado en GEDO';
+  if (status === 'CANCELLED') return 'Cancelado';
+  return 'Legado congelado';
+}
+
+function reportStatusClass(status: InspectionReportDetailF4['status']): string {
+  if (status === 'OFFICIALIZED') return 'active';
+  if (status === 'CANCELLED') return 'danger';
   return 'pending';
 }
 
-function revisionSource(value: 'AUTO' | 'DIRECTOR_UPLOAD'): string {
-  return value === 'AUTO' ? 'Automática' : 'Corrección cargada';
+function followUpLabel(type: InspectionReportFollowUpType): string {
+  if (type === 'COMPANY_NOTE') return 'Presentación / nota de empresa';
+  if (type === 'COMPANY_DOCUMENT') return 'Documento de empresa';
+  if (type === 'INTERNAL_NOTE') return 'Nota interna';
+  if (type === 'VERIFICATION') return 'Verificación';
+  return 'Otro antecedente';
+}
+
+function fileSize(value: number | null): string {
+  if (!value || value < 1) return '';
+  if (value < 1024) return `${value} B`;
+  if (value < 1024 * 1024) return `${Math.round(value / 1024)} KB`;
+  return `${(value / (1024 * 1024)).toFixed(1)} MB`;
 }
 
 export function ReportDetailPage() {
   const { id } = useParams();
   const { hasPermission } = useAuth();
-  const [report, setReport] = useState<InspectionReport | null>(null);
-  const [review, setReview] = useState<InspectionReportReview | null>(null);
+  const canManage = hasPermission('inspection_reports.generate');
+  const [report, setReport] = useState<InspectionReportDetailF4 | null>(null);
+  const [followUps, setFollowUps] = useState<InspectionReportFollowUp[]>([]);
   const [loading, setLoading] = useState(true);
   const [working, setWorking] = useState(false);
   const [error, setError] = useState('');
   const [success, setSuccess] = useState('');
-  const [revisionFile, setRevisionFile] = useState<File | null>(null);
-  const [changeSummary, setChangeSummary] = useState('');
-  const [approvalNote, setApprovalNote] = useState('');
-  const [signatureConfirmed, setSignatureConfirmed] = useState(false);
-  const canRevise = hasPermission('inspection_reports.revise');
-  const canReview = hasPermission('inspection_reports.review');
-  const canSign = hasPermission('inspection_reports.sign_final');
+
+  const [executiveSummary, setExecutiveSummary] = useState('');
+  const [reportDescription, setReportDescription] = useState('');
+
+  const [gedoIfIdentifier, setGedoIfIdentifier] = useState('');
+  const [gedoOfficializedAt, setGedoOfficializedAt] = useState(localDateTime(new Date()));
+  const [gedoFile, setGedoFile] = useState<File | null>(null);
+
+  const [followUpType, setFollowUpType] = useState<InspectionReportFollowUpType>('COMPANY_NOTE');
+  const [followUpOccurredAt, setFollowUpOccurredAt] = useState(localDateTime(new Date()));
+  const [followUpReference, setFollowUpReference] = useState('');
+  const [followUpDescription, setFollowUpDescription] = useState('');
+  const [followUpFile, setFollowUpFile] = useState<File | null>(null);
 
   const reload = async () => {
     if (!id) return;
-    const [nextReport, nextReview] = await Promise.all([getInspectionReport(id), getInspectionReportReview(id)]);
+    const [nextReport, nextFollowUps] = await Promise.all([
+      getInspectionReportF4(id),
+      listInspectionReportFollowUps(id),
+    ]);
     setReport(nextReport);
-    setReview(nextReview);
+    setFollowUps(nextFollowUps);
+    setExecutiveSummary(nextReport.executiveSummary ?? '');
+    setReportDescription(nextReport.reportDescription ?? '');
+    setGedoIfIdentifier(nextReport.gedoIfIdentifier ?? '');
+    if (nextReport.gedoOfficializedAt) {
+      setGedoOfficializedAt(localDateTime(new Date(nextReport.gedoOfficializedAt)));
+    }
   };
 
   useEffect(() => {
@@ -69,19 +106,19 @@ export function ReportDetailPage() {
       .finally(() => setLoading(false));
   }, [id]);
 
-  const uploadRevision = async (event: FormEvent) => {
+  const saveNarrative = async (event: FormEvent) => {
     event.preventDefault();
-    if (!id || !revisionFile || changeSummary.trim().length < 5) return;
+    if (!id || report?.status !== 'WORKING') return;
     setWorking(true);
     setError('');
     setSuccess('');
     try {
-      const next = await uploadInspectionReportRevision(id, revisionFile, changeSummary.trim());
-      setReview(next);
-      setRevisionFile(null);
-      setChangeSummary('');
-      setSuccess(`Versión ${next.currentRevisionNumber} agregada al historial.`);
+      await updateInspectionReportNarrative(id, {
+        executiveSummary: executiveSummary.trim() || null,
+        description: reportDescription.trim() || null,
+      });
       await reload();
+      setSuccess('Contenido editable del INF actualizado. El Acta fuente y sus Hallazgos no fueron modificados.');
     } catch (requestError) {
       setError(errorMessage(requestError));
     } finally {
@@ -89,17 +126,21 @@ export function ReportDetailPage() {
     }
   };
 
-  const approve = async () => {
-    if (!id) return;
+  const officialize = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!id || !gedoFile || !gedoIfIdentifier.trim() || !gedoOfficializedAt) return;
     setWorking(true);
     setError('');
     setSuccess('');
     try {
-      const next = await approveInspectionReport(id, approvalNote);
-      setReview(next);
-      setApprovalNote('');
-      setSuccess(`Versión ${next.currentRevisionNumber} aprobada por el Director.`);
+      await officializeInspectionReport(id, {
+        gedoIfIdentifier: gedoIfIdentifier.trim(),
+        gedoOfficializedAt: new Date(gedoOfficializedAt).toISOString(),
+        file: gedoFile,
+      });
+      setGedoFile(null);
       await reload();
+      setSuccess('IF oficial de GEDO registrado. El PDF y su hash quedaron fijados de forma inmutable.');
     } catch (requestError) {
       setError(errorMessage(requestError));
     } finally {
@@ -107,17 +148,27 @@ export function ReportDetailPage() {
     }
   };
 
-  const signFinal = async () => {
-    if (!id || !signatureConfirmed) return;
+  const addFollowUp = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!id || !followUpOccurredAt) return;
+    if (!followUpDescription.trim() && !followUpReference.trim() && !followUpFile) return;
     setWorking(true);
     setError('');
     setSuccess('');
     try {
-      const next = await signFinalInspectionReport(id);
-      setReview(next);
-      setSignatureConfirmed(false);
-      setSuccess('Informe final firmado electrónicamente. La versión firmada quedó bloqueada.');
-      await reload();
+      const next = await addInspectionReportFollowUp(id, {
+        type: followUpType,
+        occurredAt: new Date(followUpOccurredAt).toISOString(),
+        externalReference: followUpReference.trim() || null,
+        description: followUpDescription.trim() || null,
+        file: followUpFile,
+      });
+      setFollowUps(next);
+      setFollowUpReference('');
+      setFollowUpDescription('');
+      setFollowUpFile(null);
+      setFollowUpOccurredAt(localDateTime(new Date()));
+      setSuccess('Antecedente agregado al seguimiento del INF. Los registros anteriores permanecen intactos.');
     } catch (requestError) {
       setError(errorMessage(requestError));
     } finally {
@@ -130,77 +181,99 @@ export function ReportDetailPage() {
   return <section>
     <div className="breadcrumb"><Link to="/informes">Informes</Link><span>/</span><span>{report?.code ?? 'Informe'}</span></div>
     <div className="page-heading survey-editor-heading">
-      <div><span className="eyebrow">INFORME DE INSPECCIÓN</span><h1>{report?.title ?? 'Informe'}</h1><p>{report ? `${report.code} · emitido ${formatDate(report.generatedAt)}` : 'Consulta del informe.'}</p></div>
-      {report && <div className="report-status-stack"><span className={`status-badge large ${report.wordStatus === 'READY' ? 'active' : report.wordStatus === 'FAILED' ? 'danger' : 'pending'}`}>{report.wordStatus === 'READY' ? 'Word disponible' : report.wordStatus === 'FAILED' ? 'Word con error' : 'Word pendiente'}</span><span className={`status-badge large ${reviewClass(report.reviewStatus)}`}>{reviewLabel(report.reviewStatus)}</span></div>}
+      <div><span className="eyebrow">INFORME DE INSPECCIÓN</span><h1>{report?.code ?? 'Informe'}</h1><p>{report ? `Acta ${report.act.code} · generado ${formatDate(report.generatedAt)}` : 'Consulta del informe.'}</p></div>
+      {report && <div className="report-status-stack">
+        <span className={`status-badge large ${report.wordStatus === 'READY' ? 'active' : report.wordStatus === 'FAILED' ? 'danger' : 'pending'}`}>{report.wordStatus === 'READY' ? 'Word disponible' : report.wordStatus === 'FAILED' ? 'Word con error' : 'Word pendiente'}</span>
+        <span className={`status-badge large ${reportStatusClass(report.status)}`}>{reportStatusLabel(report.status)}</span>
+      </div>}
     </div>
+
     {error && <Alert>{error}</Alert>}
-    {success && <div className="success-banner">{success}</div>}
+    {success && <Alert type="success">{success}</Alert>}
+
     {report && <>
-      <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Informe Word automático.</strong> La versión inicial se genera desde la instantánea congelada del Acta. Las correcciones se agregan como nuevas versiones y nunca sobrescriben la anterior.</p></div>
+      <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Un INF corresponde a una sola Acta.</strong> El Word puede editarse durante la preparación del Informe. El Acta sellada y los Hallazgos que contiene permanecen inmutables.</p></div>
+
       <section className="panel report-summary-panel">
         <div className="panel-heading"><div><span className="eyebrow">TRAZABILIDAD DOCUMENTAL</span><h2>{report.code}</h2></div><small className="muted">Versión del Acta: {report.actVersion}</small></div>
         <div className="responsible-summary">
           <div><small>Empresa</small><strong>{names(report.companies, 'Sin asignar')}</strong></div>
-          <div><small>Área</small><strong>{names(report.areas, 'Sin asignar')}</strong></div>
+          <div><small>Área / Yacimiento</small><strong>{names(report.areas, 'Sin asignar')}</strong></div>
           <div><small>Hallazgos</small><strong>{report.findingCount}</strong></div>
-          <div><small>Emitido por</small><strong>{report.generatedBy.firstName} {report.generatedBy.lastName}</strong></div>
+          <div><small>Generado por</small><strong>{report.generatedBy.firstName} {report.generatedBy.lastName}</strong></div>
         </div>
-        {report.wordStatus === 'READY' && <div className="page-actions"><a className="button secondary" href={inspectionReportWordUrl(report.id)}>Descargar Word automático</a></div>}
         <div className="report-linked-documents">
           <Link to={`/inspecciones/${report.visitId}`}><span>Inspección</span><strong>{report.visit.code}</strong><Icon name="chevron" /></Link>
-          <Link to={`/inspecciones/actas/${report.actId}`}><span>Acta incorporada</span><strong>{report.act.code}</strong><small>{report.act.title}</small><Icon name="chevron" /></Link>
-          <Link to={`/hallazgos?search=${encodeURIComponent(report.act.code)}`}><span>Hallazgos</span><strong>{report.findingCount}</strong><small>Ver seguimiento relacionado</small><Icon name="chevron" /></Link>
+          <Link to={`/inspecciones/actas/${report.actId}`}><span>Acta fuente</span><strong>{report.act.code}</strong><small>Contenido inmutable</small><Icon name="chevron" /></Link>
+          <Link to={`/hallazgos?search=${encodeURIComponent(report.act.code)}`}><span>Hallazgos del Acta</span><strong>{report.findingCount}</strong><small>Seguimiento técnico</small><Icon name="chevron" /></Link>
         </div>
       </section>
 
-      <section className="panel report-review-panel">
-        <div className="panel-heading"><div><span className="eyebrow">REVISIÓN DIRECTIVA</span><h2>Versiones y firma final</h2><p className="section-copy">El Acta y los Hallazgos originales permanecen congelados. La revisión sólo versiona el documento Informe.</p></div>{review && <span className={`status-badge large ${reviewClass(review.reviewStatus)}`}>{reviewLabel(review.reviewStatus)}</span>}</div>
-        {!review ? <LoadingBlock label="Cargando revisión…" /> : <>
-          <div className="review-flow">
-            <div className="complete"><span>1</span><strong>Informe automático</strong><small>{review.revisions.length ? 'Versión inicial registrada' : 'Esperando Word'}</small></div>
-            <div className={review.currentRevisionNumber > 1 ? 'complete' : ''}><span>2</span><strong>Correcciones</strong><small>{review.currentRevisionNumber > 1 ? `${review.currentRevisionNumber - 1} versión/es agregada/s` : 'Sin correcciones'}</small></div>
-            <div className={review.reviewStatus !== 'PENDING_REVIEW' ? 'complete' : ''}><span>3</span><strong>Aprobación</strong><small>{review.approvedAt ? formatDate(review.approvedAt) : 'Pendiente del Director'}</small></div>
-            <div className={review.reviewStatus === 'SIGNED' ? 'complete' : ''}><span>4</span><strong>Firma final</strong><small>{review.signature ? formatDate(review.signature.signedAt) : 'Pendiente'}</small></div>
+      <section className="panel">
+        <div className="panel-heading"><div><span className="eyebrow">WORD EDITABLE</span><h2>Preparación del INF</h2><p className="section-copy">El Inspector puede revisar y ajustar el texto del Informe antes de incorporarlo a GEDO. Esta edición no altera el Acta fuente.</p></div>{report.wordStatus === 'READY' && <a className="button secondary" href={inspectionReportWordDownloadUrl(report.id)}>Descargar Word</a>}</div>
+        <form className="form-section" onSubmit={saveNarrative}>
+          <label className="field"><span>Resumen ejecutivo</span><textarea rows={4} maxLength={20000} value={executiveSummary} onChange={(event) => setExecutiveSummary(event.target.value)} disabled={!canManage || report.status !== 'WORKING'} placeholder="Resumen ejecutivo del Informe…" /></label>
+          <label className="field"><span>Descripción / análisis técnico</span><textarea rows={8} maxLength={50000} value={reportDescription} onChange={(event) => setReportDescription(event.target.value)} disabled={!canManage || report.status !== 'WORKING'} placeholder="Descripción técnica, análisis y consideraciones del Inspector…" /></label>
+          {canManage && report.status === 'WORKING' && <div className="form-actions"><button className="button primary" disabled={working}>{working ? 'Guardando…' : 'Guardar contenido del INF'}</button></div>}
+          {report.status !== 'WORKING' && <Alert type="info">El contenido editable se cerró al registrar el IF oficial de GEDO.</Alert>}
+        </form>
+      </section>
+
+      <section className="panel">
+        <div className="panel-heading"><div><span className="eyebrow">GEDO</span><h2>Oficialización del Informe</h2><p className="section-copy">Cuando GEDO devuelve el IF y el PDF oficial, ambos se registran en el sistema y pasan a ser la referencia documental institucional.</p></div></div>
+        {report.status === 'OFFICIALIZED' ? <>
+          <div className="responsible-summary">
+            <div><small>Identificador IF</small><strong>{report.gedoIfIdentifier ?? '—'}</strong></div>
+            <div><small>Oficializado</small><strong>{formatDate(report.gedoOfficializedAt)}</strong></div>
+            <div><small>PDF oficial</small><strong>{report.gedoPdfOriginalName ?? 'Registrado'}</strong></div>
+            <div><small>Vencimiento del Acta</small><strong>{formatDate(report.act.deadlineAt)}</strong></div>
           </div>
-
-          <div className="report-revision-list">
-            {review.revisions.map((revision) => <article key={revision.id} className={review.approvedRevisionId === revision.id ? 'approved' : ''}>
-              <div><span className="status-badge">Versión {revision.revisionNumber}</span><strong>{revision.originalName}</strong><small>{revisionSource(revision.source)} · {revision.createdBy.firstName} {revision.createdBy.lastName} · {formatDate(revision.createdAt)}</small>{revision.changeSummary && <p>{revision.changeSummary}</p>}</div>
-              <div className="revision-actions"><code title={revision.sha256}>{revision.sha256}</code><a className="button secondary" href={inspectionReportRevisionUrl(revision.id)}>Descargar</a></div>
-            </article>)}
+          {report.gedoPdfSha256 && <div className="temporal-notice"><Icon name="check" /><p><strong>PDF GEDO fijado.</strong> SHA-256: <code>{report.gedoPdfSha256}</code></p></div>}
+        </> : canManage && report.status === 'WORKING' ? <form className="form-section" onSubmit={officialize}>
+          <div className="form-grid">
+            <label className="field"><span>Identificador IF de GEDO</span><input value={gedoIfIdentifier} onChange={(event) => setGedoIfIdentifier(event.target.value)} required maxLength={255} placeholder="IF-2026-…" /></label>
+            <label className="field"><span>Fecha de oficialización</span><input type="datetime-local" value={gedoOfficializedAt} onChange={(event) => setGedoOfficializedAt(event.target.value)} required /></label>
           </div>
+          <label className="field"><span>PDF oficial de GEDO</span><input type="file" accept="application/pdf,.pdf" onChange={(event) => setGedoFile(event.target.files?.[0] ?? null)} required /></label>
+          <Alert>Esta acción cierra la edición del INF. El IF, la fecha y el hash del PDF oficial quedarán registrados como trazabilidad institucional.</Alert>
+          <div className="form-actions"><button className="button primary" disabled={working || !gedoFile || !gedoIfIdentifier.trim()}>{working ? 'Registrando…' : 'Registrar IF y PDF oficial'}</button></div>
+        </form> : <Alert type="info">El Informe todavía no está oficializado en GEDO.</Alert>}
+      </section>
 
-          {canRevise && review.reviewStatus === 'PENDING_REVIEW' && <form className="report-review-form" onSubmit={uploadRevision}>
-            <div><span className="eyebrow">NUEVA VERSIÓN</span><h3>Agregar Word corregido</h3><p className="section-copy">Descargá la última versión, realizá la corrección en Word y cargala nuevamente. La versión anterior queda intacta.</p></div>
-            <label><span>Archivo .docx</span><input type="file" accept=".docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document" onChange={(event) => setRevisionFile(event.target.files?.[0] ?? null)} /></label>
-            <label><span>Resumen de cambios</span><textarea value={changeSummary} onChange={(event) => setChangeSummary(event.target.value)} maxLength={1000} placeholder="Ej.: Se corrigió la conclusión técnica y la referencia del equipo inspeccionado." /></label>
-            <button className="button primary" disabled={working || !revisionFile || changeSummary.trim().length < 5}>Agregar versión</button>
-          </form>}
+      <section className="panel">
+        <div className="panel-heading"><div><span className="eyebrow">SEGUIMIENTO DEL INF</span><h2>Presentaciones y antecedentes</h2><p className="section-copy">Las respuestas de empresa, documentos, notas internas y verificaciones se agregan cronológicamente. Nunca reemplazan un antecedente anterior.</p></div><span className="count-pill">{followUps.length}</span></div>
 
-          {canReview && review.reviewStatus === 'PENDING_REVIEW' && review.revisions.length > 0 && <div className="report-review-action">
-            <div><span className="eyebrow">APROBACIÓN</span><h3>Aprobar versión {review.currentRevisionNumber}</h3><p>La aprobación fija esta versión como candidata a firma final. Después de aprobar no se podrán cargar nuevas correcciones.</p></div>
-            <label><span>Nota de revisión opcional</span><textarea value={approvalNote} onChange={(event) => setApprovalNote(event.target.value)} maxLength={1000} placeholder="Observación interna de aprobación" /></label>
-            <button type="button" className="button primary" disabled={working} onClick={approve}>Aprobar versión actual</button>
-          </div>}
+        {followUps.length === 0 ? <div className="inline-empty">Todavía no hay antecedentes posteriores registrados.</div> : <div className="dossier-link-list">
+          {[...followUps].reverse().map((item) => <div key={item.id}>
+            <div>
+              <strong>{followUpLabel(item.type)}</strong>
+              <small>{item.description || item.externalReference || item.originalName || 'Sin descripción'}</small>
+              {item.originalName && <small>Archivo: {item.originalName}{item.sizeBytes ? ` · ${fileSize(item.sizeBytes)}` : ''}</small>}
+            </div>
+            <span>{formatDate(item.occurredAt)}{item.externalReference ? ` · ${item.externalReference}` : ''}</span>
+          </div>)}
+        </div>}
 
-          {canSign && review.reviewStatus === 'APPROVED' && <div className="report-review-action final-signature-action">
-            <div><span className="eyebrow">FIRMA FINAL</span><h3>Firma electrónica del Director</h3><p>La firma vincula de forma inmutable al Director, la versión aprobada, el hash del Informe y la fecha. Una vez firmada no admite nuevas versiones.</p></div>
-            <label className="check-label"><input type="checkbox" checked={signatureConfirmed} onChange={(event) => setSignatureConfirmed(event.target.checked)} /><span>Confirmo que revisé la versión aprobada y firmo electrónicamente el informe final como Director de Hidrocarburos.</span></label>
-            <button type="button" className="button primary" disabled={working || !signatureConfirmed} onClick={signFinal}>Firmar informe final</button>
-          </div>}
-
-          {review.signature && <div className="signed-report-box"><Icon name="check" /><div><strong>Informe final firmado</strong><p>{review.signature.signedBy.firstName} {review.signature.signedBy.lastName} · {formatDate(review.signature.signedAt)}</p><code title={review.signature.signatureSha256}>{review.signature.signatureSha256}</code></div></div>}
-          {review.reviewStatus === 'SIGNED' && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Firma cerrada.</strong> La firma electrónica ya prueba quién aprobó la versión y qué hash fue firmado. La ubicación visual de la rúbrica dentro del documento se resolverá con la plantilla institucional definitiva.</p></div>}
-        </>}
+        {canManage && <form className="form-section" onSubmit={addFollowUp}>
+          <div><h3>Agregar antecedente</h3><p className="section-copy">Usá este bloque para registrar una nueva presentación sin modificar las anteriores.</p></div>
+          <div className="form-grid">
+            <label className="field"><span>Tipo</span><SearchableSelect value={followUpType} onChange={(event) => setFollowUpType(event.target.value as InspectionReportFollowUpType)}><option value="COMPANY_NOTE">Presentación / nota de empresa</option><option value="COMPANY_DOCUMENT">Documento de empresa</option><option value="INTERNAL_NOTE">Nota interna</option><option value="VERIFICATION">Verificación</option><option value="OTHER">Otro antecedente</option></SearchableSelect></label>
+            <label className="field"><span>Fecha</span><input type="datetime-local" value={followUpOccurredAt} onChange={(event) => setFollowUpOccurredAt(event.target.value)} required /></label>
+            <label className="field"><span>Referencia externa <em>opcional</em></span><input value={followUpReference} onChange={(event) => setFollowUpReference(event.target.value)} maxLength={255} placeholder="GEDO, expediente, nota, ticket…" /></label>
+          </div>
+          <label className="field"><span>Descripción</span><textarea rows={4} maxLength={20000} value={followUpDescription} onChange={(event) => setFollowUpDescription(event.target.value)} placeholder="Contenido o resumen de la presentación…" /></label>
+          <label className="field"><span>Archivo <em>opcional</em></span><input type="file" onChange={(event) => setFollowUpFile(event.target.files?.[0] ?? null)} /></label>
+          <div className="form-actions"><button className="button primary" disabled={working || (!followUpDescription.trim() && !followUpReference.trim() && !followUpFile)}>{working ? 'Agregando…' : 'Agregar al historial'}</button></div>
+        </form>}
       </section>
 
       <section className="panel report-integrity-panel">
-        <div className="panel-heading"><div><span className="eyebrow">INTEGRIDAD</span><h2>Contenido congelado</h2><p className="section-copy">El Informe conserva la versión exacta del Acta cerrada y su instantánea documental.</p></div></div>
+        <div className="panel-heading"><div><span className="eyebrow">INTEGRIDAD</span><h2>Fuente inmutable</h2><p className="section-copy">El INF conserva una copia verificable del Acta sellada que le dio origen.</p></div></div>
         <dl className="report-integrity-list">
+          <div><dt>Acta fuente</dt><dd>{report.act.code}</dd></div>
           <div><dt>Hash de cierre del Acta</dt><dd>{report.actClosureSha256}</dd></div>
-          <div><dt>Hash del Informe</dt><dd>{report.frozenSha256}</dd></div>
-          <div><dt>Estado base</dt><dd>{report.status === 'FROZEN' ? 'Congelado' : 'Cancelado'}</dd></div>
-          <div><dt>Revisión</dt><dd>{reviewLabel(report.reviewStatus)}</dd></div>
+          <div><dt>Hash de la fuente del INF</dt><dd>{report.frozenSha256}</dd></div>
+          <div><dt>Estado del INF</dt><dd>{reportStatusLabel(report.status)}</dd></div>
         </dl>
       </section>
     </>}

From c715029dbcd9c8f25166b8ee1bfbea047e26a53d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:47:43 -0300
Subject: [PATCH 088/224] F4: add report list contracts to web client

---
 web-v2/src/lib/reportWorkflowApi.ts | 61 +++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/web-v2/src/lib/reportWorkflowApi.ts b/web-v2/src/lib/reportWorkflowApi.ts
index 03942f4..db1d3a6 100644
--- a/web-v2/src/lib/reportWorkflowApi.ts
+++ b/web-v2/src/lib/reportWorkflowApi.ts
@@ -8,6 +8,25 @@ export type InspectionReportFollowUpType =
   | 'VERIFICATION'
   | 'OTHER';
 
+export interface PageMetaF4 {
+  page: number;
+  pageSize: number;
+  total: number;
+  totalPages: number;
+}
+
+export interface InspectionReportQueryF4 {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  year?: number | string;
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+}
+
 export interface InspectionReportDetailF4 {
   id: string;
   visitId: string;
@@ -47,6 +66,22 @@ export interface InspectionReportDetailF4 {
   findingCount: number;
 }
 
+export interface PendingInspectionReportF4 {
+  actId: string;
+  visitId: string;
+  actCode: string;
+  actTitle: string;
+  actYear: number;
+  occurredAt: string;
+  sealedAt: string;
+  closureSha256: string;
+  visitCode: string;
+  visitTitle: string;
+  companies: Array<{ id: string; code: string; name: string }>;
+  areas: Array<{ id: string; code: string; name: string }>;
+  findingCount: number;
+}
+
 export interface InspectionReportFollowUp {
   id: string;
   reportId: string;
@@ -84,6 +119,32 @@ export interface InspectionReportWorkflowView {
   followUps: InspectionReportFollowUp[];
 }
 
+function queryString(query: InspectionReportQueryF4): string {
+  const params = new URLSearchParams();
+  const add = (key: string, value: string | number | undefined) => {
+    if (value === undefined || value === '') return;
+    params.set(key, String(value));
+  };
+  add('page', query.page ?? 1);
+  add('pageSize', query.pageSize ?? 25);
+  add('search', query.search?.trim() || undefined);
+  add('year', query.year);
+  add('companyId', query.companyId);
+  add('areaId', query.areaId);
+  add('inspectorId', query.inspectorId);
+  add('dateFrom', query.dateFrom);
+  add('dateTo', query.dateTo);
+  return params.toString();
+}
+
+export function listInspectionReportsF4(query: InspectionReportQueryF4) {
+  return apiRequest<{ data: InspectionReportDetailF4[]; meta: PageMetaF4 }>(`/inspection-reports?${queryString(query)}`);
+}
+
+export function listPendingInspectionReportsF4(query: InspectionReportQueryF4) {
+  return apiRequest<{ data: PendingInspectionReportF4[]; meta: PageMetaF4 }>(`/inspection-reports/pending?${queryString(query)}`);
+}
+
 export function getInspectionReportF4(id: string) {
   return apiRequest<InspectionReportDetailF4>(`/inspection-reports/${id}`);
 }

From 408fd5990d3e0b47213ad2352cfb1f9272ddc0fc Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:48:18 -0300
Subject: [PATCH 089/224] F4: align report list with INF GEDO workflow

---
 web-v2/src/pages/ReportsPage.tsx | 72 ++++++++++++++++++++------------
 1 file changed, 45 insertions(+), 27 deletions(-)

diff --git a/web-v2/src/pages/ReportsPage.tsx b/web-v2/src/pages/ReportsPage.tsx
index 4a1f156..ffc90e2 100644
--- a/web-v2/src/pages/ReportsPage.tsx
+++ b/web-v2/src/pages/ReportsPage.tsx
@@ -6,8 +6,15 @@ import { Icon } from '../components/Icon';
 import { useOperationalContext } from '../context/OperationalContext';
 import { DocumentCenterTabs } from '../features/documents/DocumentCenterTabs';
 import { OperationalFilters } from '../features/inspections/OperationalFilters';
-import { listInspectionReports, listPendingInspectionReports } from '../lib/api';
-import type { InspectionReportListItem, PageMeta, PendingInspectionReportItem } from '../lib/api';
+import {
+  listInspectionReportsF4,
+  listPendingInspectionReportsF4,
+} from '../lib/reportWorkflowApi';
+import type {
+  InspectionReportDetailF4,
+  PageMetaF4,
+  PendingInspectionReportF4,
+} from '../lib/reportWorkflowApi';
 import { formatDate } from '../lib/format';
 
 function contextLabel(items: Array<{ name: string }>, empty: string): string {
@@ -18,16 +25,16 @@ function contextLabel(items: Array<{ name: string }>, empty: string): string {
   return `${first.name} +${items.length - 1}`;
 }
 
-
-function reviewLabel(value: InspectionReportListItem['reviewStatus']): string {
-  if (value === 'SIGNED') return 'Firmado';
-  if (value === 'APPROVED') return 'Aprobado';
-  return 'Pendiente';
+function statusLabel(report: InspectionReportDetailF4): string {
+  if (report.status === 'OFFICIALIZED') return report.gedoIfIdentifier ? `GEDO · ${report.gedoIfIdentifier}` : 'Oficializado en GEDO';
+  if (report.status === 'WORKING') return 'En preparación';
+  if (report.status === 'CANCELLED') return 'Cancelado';
+  return 'Legado congelado';
 }
 
-function reviewClass(value: InspectionReportListItem['reviewStatus']): string {
-  if (value === 'SIGNED') return 'active';
-  if (value === 'APPROVED') return 'observed';
+function statusClass(report: InspectionReportDetailF4): string {
+  if (report.status === 'OFFICIALIZED') return 'active';
+  if (report.status === 'CANCELLED') return 'danger';
   return 'pending';
 }
 
@@ -44,9 +51,9 @@ export function ReportsPage() {
   const dateTo = params.get('dateTo') ?? '';
   const page = Math.max(1, Number(params.get('page') ?? 1) || 1);
   const [draftSearch, setDraftSearch] = useState(search);
-  const [issued, setIssued] = useState<InspectionReportListItem[]>([]);
-  const [pending, setPending] = useState<PendingInspectionReportItem[]>([]);
-  const [meta, setMeta] = useState<PageMeta>({ page: 1, pageSize: 25, total: 0, totalPages: 0 });
+  const [issued, setIssued] = useState<InspectionReportDetailF4[]>([]);
+  const [pending, setPending] = useState<PendingInspectionReportF4[]>([]);
+  const [meta, setMeta] = useState<PageMetaF4>({ page: 1, pageSize: 25, total: 0, totalPages: 0 });
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState('');
 
@@ -54,16 +61,27 @@ export function ReportsPage() {
     let cancelled = false;
     setLoading(true);
     setError('');
+    const query = {
+      page,
+      pageSize: 25,
+      search,
+      year: year ? Number(year) : undefined,
+      companyId,
+      areaId,
+      inspectorId,
+      dateFrom,
+      dateTo,
+    };
     const load = async () => {
       try {
         if (view === 'issued') {
-          const response = await listInspectionReports({ page, pageSize: 25, search, year: year ? Number(year) : '', companyId, areaId, inspectorId, dateFrom, dateTo });
+          const response = await listInspectionReportsF4(query);
           if (cancelled) return;
           setIssued(response.data);
           setPending([]);
           setMeta(response.meta);
         } else {
-          const response = await listPendingInspectionReports({ page, pageSize: 25, search, year: year ? Number(year) : '', companyId, areaId, inspectorId, dateFrom, dateTo });
+          const response = await listPendingInspectionReportsF4(query);
           if (cancelled) return;
           setPending(response.data);
           setIssued([]);
@@ -110,39 +128,39 @@ export function ReportsPage() {
 
   return <section>
     <div className="page-heading">
-      <div><span className="eyebrow">CENTRO DOCUMENTAL</span><h1>Informes</h1><p>Registro global de informes de inspección generados automáticamente al cerrar cada visita.</p></div>
+      <div><span className="eyebrow">CENTRO DOCUMENTAL</span><h1>Informes</h1><p>Cada Acta sellada genera un único INF editable. Luego el IF y PDF oficial de GEDO completan su trazabilidad institucional.</p></div>
     </div>
     <DocumentCenterTabs />
 
     <div className="document-view-tabs">
-      <button type="button" className={view === 'issued' ? 'active' : ''} onClick={() => setFilter('view', 'issued')}>Informes emitidos</button>
-      <button type="button" className={view === 'pending' ? 'active' : ''} onClick={() => setFilter('view', 'pending')}>Pendientes de emisión</button>
+      <button type="button" className={view === 'issued' ? 'active' : ''} onClick={() => setFilter('view', 'issued')}>Informes</button>
+      <button type="button" className={view === 'pending' ? 'active' : ''} onClick={() => setFilter('view', 'pending')}>Actas selladas sin INF</button>
     </div>
 
     <form className="toolbar survey-toolbar" onSubmit={applySearch}>
-      <label className="search-field"><Icon name="search" /><input value={draftSearch} onChange={(event) => setDraftSearch(event.target.value)} placeholder="Buscar informe, acta, inspección, empresa o área" /><button>Buscar</button></label>
+      <label className="search-field"><Icon name="search" /><input value={draftSearch} onChange={(event) => setDraftSearch(event.target.value)} placeholder="Buscar INF, IF GEDO, acta, inspección, empresa o área" /><button>Buscar</button></label>
       <label className="select-field"><span>Año</span><input inputMode="numeric" value={year} onChange={(event) => setFilter('year', event.target.value.replace(/\D/g, '').slice(0, 4))} placeholder="Todos" /></label>
       <OperationalFilters inspectorId={inspectorId} dateFrom={dateFrom} dateTo={dateTo} onChange={setFilter} />
     </form>
 
-    {view === 'pending' && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Recuperación documental.</strong> Las actas históricas sin informe aparecen aquí. Desde D5.3.20 el informe se numera y congela automáticamente al cerrar la visita.</p></div>}
+    {view === 'pending' && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Actas listas para generar INF.</strong> Esta bandeja sólo muestra Actas selladas que todavía no tienen su Informe 1 a 1.</p></div>}
     {error && <Alert>{error}</Alert>}
-    {loading ? <LoadingBlock label={view === 'issued' ? 'Cargando informes…' : 'Cargando pendientes…'} /> : empty ? <EmptyState title={view === 'issued' ? 'Sin informes emitidos' : 'Sin informes pendientes'} text={view === 'issued' ? 'Todavía no hay informes emitidos para los filtros seleccionados.' : 'Todas las actas cerradas tienen su informe emitido.'} /> : <div className="table-panel document-table">
-      <div className="table-summary"><strong>{meta.total} {view === 'issued' ? `informe${meta.total === 1 ? '' : 's'}` : `pendiente${meta.total === 1 ? '' : 's'}`}</strong><span>Página {page} de {Math.max(meta.totalPages, 1)}</span></div>
-      <div className="table-scroll"><table><thead>{view === 'issued' ? <tr><th>Informe</th><th>Empresa / área</th><th>Acta</th><th>Hallazgos</th><th>Word</th><th>Revisión</th><th /></tr> : <tr><th>Acta cerrada</th><th>Empresa / área</th><th>Inspección</th><th>Hallazgos</th><th>Cierre</th><th /></tr>}</thead><tbody>{view === 'issued' ? issued.map((report) => <tr key={report.id}>
+    {loading ? <LoadingBlock label={view === 'issued' ? 'Cargando informes…' : 'Cargando actas pendientes…'} /> : empty ? <EmptyState title={view === 'issued' ? 'Sin informes' : 'Sin actas pendientes'} text={view === 'issued' ? 'Todavía no hay informes para los filtros seleccionados.' : 'Todas las Actas selladas tienen su INF correspondiente.'} /> : <div className="table-panel document-table">
+      <div className="table-summary"><strong>{meta.total} {view === 'issued' ? `informe${meta.total === 1 ? '' : 's'}` : `acta${meta.total === 1 ? '' : 's'} pendiente${meta.total === 1 ? '' : 's'}`}</strong><span>Página {page} de {Math.max(meta.totalPages, 1)}</span></div>
+      <div className="table-scroll"><table><thead>{view === 'issued' ? <tr><th>Informe</th><th>Empresa / área</th><th>Acta</th><th>Hallazgos</th><th>Word</th><th>Estado</th><th /></tr> : <tr><th>Acta sellada</th><th>Empresa / área</th><th>Inspección</th><th>Hallazgos</th><th>Sellado</th><th /></tr>}</thead><tbody>{view === 'issued' ? issued.map((report) => <tr key={report.id}>
         <td><div className="document-primary"><strong>{report.code}</strong><small>{report.title} · {formatDate(report.generatedAt)}</small></div></td>
         <td><div className="document-primary"><strong>{contextLabel(report.companies, 'Empresa sin asignar')}</strong><small>{contextLabel(report.areas, 'Área sin asignar')}</small></div></td>
         <td><Link className="text-link" to={`/inspecciones/actas/${report.actId}`}>{report.act.code}<small className="block-muted">{report.act.title}</small></Link></td>
         <td><Link className="text-link" to={`/hallazgos?search=${encodeURIComponent(report.act.code)}`}>{report.findingCount}</Link></td>
-        <td><span className={`status-badge ${report.wordStatus === 'READY' ? 'active' : report.wordStatus === 'FAILED' ? 'danger' : 'pending'}`}>{report.wordStatus === 'READY' ? 'Word disponible' : report.wordStatus === 'FAILED' ? 'Word con error' : 'Word pendiente'}</span></td>
-        <td><span className={`status-badge ${reviewClass(report.reviewStatus)}`}>{reviewLabel(report.reviewStatus)}</span></td>
+        <td><span className={`status-badge ${report.wordStatus === 'READY' ? 'active' : report.wordStatus === 'FAILED' ? 'danger' : 'pending'}`}>{report.wordStatus === 'READY' ? 'Disponible' : report.wordStatus === 'FAILED' ? 'Error' : 'Pendiente'}</span></td>
+        <td><span className={`status-badge ${statusClass(report)}`}>{statusLabel(report)}</span></td>
         <td className="action-cell"><Link className="icon-button" to={`/informes/${report.id}`} aria-label={`Abrir ${report.code}`}><Icon name="chevron" /></Link></td>
       </tr>) : pending.map((item) => <tr key={item.actId}>
         <td><div className="document-primary"><strong>{item.actCode}</strong><small>{item.actTitle} · {formatDate(item.occurredAt)}</small></div></td>
         <td><div className="document-primary"><strong>{contextLabel(item.companies, 'Empresa sin asignar')}</strong><small>{contextLabel(item.areas, 'Área sin asignar')}</small></div></td>
-        <td><Link className="text-link" to={`/inspecciones/${item.visitId}`}>{item.visitCode}</Link></td>
+        <td><Link className="text-link" to={`/inspecciones/${item.visitId}`}>{item.visitCode}<small className="block-muted">{item.visitTitle}</small></Link></td>
         <td><Link className="text-link" to={`/hallazgos?search=${encodeURIComponent(item.actCode)}`}>{item.findingCount}</Link></td>
-        <td>{formatDate(item.closedAt)}</td>
+        <td>{formatDate(item.sealedAt)}</td>
         <td className="action-cell"><Link className="icon-button" to={`/inspecciones/actas/${item.actId}`} aria-label={`Abrir ${item.actCode}`}><Icon name="chevron" /></Link></td>
       </tr>)}</tbody></table></div>
       <div className="pagination"><button className="button secondary" disabled={page <= 1} onClick={() => setPage(page - 1)}>Anterior</button><span>{meta.total ? `${(page - 1) * meta.pageSize + 1}–${Math.min(page * meta.pageSize, meta.total)} de ${meta.total}` : '0 resultados'}</span><button className="button secondary" disabled={page >= meta.totalPages} onClick={() => setPage(page + 1)}>Siguiente</button></div>

From 82d8af272840716579fe999304af69edf2e5fb0b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:53:41 -0300
Subject: [PATCH 090/224] F4: decouple verification planning from company
 response

---
 .../inspection-verifications.service.ts       | 25 +++----------------
 1 file changed, 4 insertions(+), 21 deletions(-)

diff --git a/api-v3/src/inspection-verifications/inspection-verifications.service.ts b/api-v3/src/inspection-verifications/inspection-verifications.service.ts
index eff5ccd..eb55fb5 100644
--- a/api-v3/src/inspection-verifications/inspection-verifications.service.ts
+++ b/api-v3/src/inspection-verifications/inspection-verifications.service.ts
@@ -30,7 +30,6 @@ interface VerificationVisitView {
   title: string;
   status: InspectionVisitStatus;
   plannedStartAt: Date | null;
-  plannedEndAt: Date | null;
 }
 
 export interface VerificationPlanningItem {
@@ -39,7 +38,6 @@ export interface VerificationPlanningItem {
   title: string;
   status: 'OPEN';
   nextControlOn: string;
-  companyResponseReceivedOn: string;
   asset: VerificationContextView & { typeName: string };
   company: VerificationContextView | null;
   area: VerificationContextView | null;
@@ -75,7 +73,6 @@ interface LockedFindingRow {
   areaId: string | null;
   areaCode: string | null;
   areaName: string | null;
-  companyResponseReceivedOn: string | null;
   nextControlOn: string | null;
   status: string;
 }
@@ -93,7 +90,6 @@ export class InspectionVerificationsService {
     const values: unknown[] = [];
     const baseFilters = [
       `finding.status = 'OPEN'`,
-      `finding.company_response_received_on IS NOT NULL`,
       `finding.next_control_on IS NOT NULL`,
       `COALESCE((
         SELECT latest_verification.outcome
@@ -134,8 +130,7 @@ export class InspectionVerificationsService {
           visit.code,
           visit.title,
           visit.status,
-          visit.planned_start_at AS "plannedStartAt",
-          visit.planned_end_at AS "plannedEndAt"
+          visit.planned_start_at AS "plannedStartAt"
         FROM inspection_finding_verification_visits verification_link
         INNER JOIN inspection_visits visit ON visit.id = verification_link.visit_id
         WHERE verification_link.finding_id = finding.id
@@ -181,7 +176,6 @@ export class InspectionVerificationsService {
         finding.title,
         finding.status,
         finding.next_control_on AS "nextControlOn",
-        finding.company_response_received_on AS "companyResponseReceivedOn",
         jsonb_build_object(
           'id', asset.id,
           'code', asset.code,
@@ -209,8 +203,7 @@ export class InspectionVerificationsService {
           'code', verification_visit.code,
           'title', verification_visit.title,
           'status', verification_visit.status,
-          'plannedStartAt', verification_visit."plannedStartAt",
-          'plannedEndAt', verification_visit."plannedEndAt"
+          'plannedStartAt', verification_visit."plannedStartAt"
         ) END AS "verificationVisit"
       FROM inspection_findings finding
       ${joins}
@@ -503,7 +496,6 @@ export class InspectionVerificationsService {
           finding.title,
           finding.status,
           finding.asset_id AS "assetId",
-          finding.company_response_received_on AS "companyResponseReceivedOn",
           finding.next_control_on AS "nextControlOn",
           asset.code AS "assetCode",
           asset.name AS "assetName",
@@ -524,13 +516,11 @@ export class InspectionVerificationsService {
       if (rows.length !== findingIds.length) {
         throw new NotFoundException({ code: 'VERIFICATION_FINDING_NOT_FOUND', message: 'Uno o más hallazgos ya no están disponibles' });
       }
-      const invalid = rows.find((row) =>
-        row.status !== 'OPEN' || !row.companyResponseReceivedOn || !row.nextControlOn,
-      );
+      const invalid = rows.find((row) => row.status !== 'OPEN' || !row.nextControlOn);
       if (invalid) {
         throw new ConflictException({
           code: 'VERIFICATION_FINDING_NOT_READY',
-          message: `${invalid.code} no está listo para una verificación planificada`,
+          message: `${invalid.code} necesita estar abierto y tener una fecha de control para planificar su verificación`,
         });
       }
       const missingContext = rows.find((row) => !row.companyId || !row.areaId);
@@ -587,7 +577,6 @@ export class InspectionVerificationsService {
         operatorCompanyId: companyId,
         leadInspectorUserId: null,
         plannedStartAt,
-        plannedEndAt: null,
         actualStartedAt: null,
         actualClosedAt: null,
         instructions,
@@ -650,7 +639,6 @@ export class InspectionVerificationsService {
           code: visit.code,
           status: visit.status,
           plannedStartAt: visit.plannedStartAt,
-          plannedEndAt: visit.plannedEndAt,
           companyId,
           areaId,
           findingIds,
@@ -665,7 +653,6 @@ export class InspectionVerificationsService {
           title: visit.title,
           status: visit.status,
           plannedStartAt: visit.plannedStartAt,
-          plannedEndAt: visit.plannedEndAt,
         },
         company: { id: companyId, code: rows[0]?.companyCode ?? '', name: companyName },
         area: { id: areaId, code: rows[0]?.areaCode ?? '', name: areaName },
@@ -719,9 +706,6 @@ export class InspectionVerificationsService {
         'title', finding.title,
         'description', finding.description,
         'correctionDueOn', finding.correction_due_on,
-        'companyResponse', finding.company_response,
-        'companyResponseReceivedOn', finding.company_response_received_on,
-        'companyCommittedCorrectionOn', finding.company_committed_correction_on,
         'nextControlOn', finding.next_control_on,
         'currentVersion', finding.current_version,
         'verification', JSONB_BUILD_OBJECT(
@@ -759,5 +743,4 @@ export class InspectionVerificationsService {
     ]);
     return versionNumber;
   }
-
 }

From 44eccaa36cba02bc88a99e27064e016aa1f2d8b4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:55:02 -0300
Subject: [PATCH 091/224] F4: align verification planning UI with technical
 workflow

---
 web-v2/src/pages/VerificationPlanningPage.tsx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/web-v2/src/pages/VerificationPlanningPage.tsx b/web-v2/src/pages/VerificationPlanningPage.tsx
index f595e84..eb975f6 100644
--- a/web-v2/src/pages/VerificationPlanningPage.tsx
+++ b/web-v2/src/pages/VerificationPlanningPage.tsx
@@ -177,11 +177,11 @@ export function VerificationPlanningPage() {
 
   return <section>
     <div className="page-heading">
-      <div><span className="eyebrow">PLANIFICACIÓN OPERATIVA</span><h1>Verificaciones de hallazgos</h1><p>Convertí la fecha de verificación en una inspección de campo, agrupando hallazgos de una misma empresa y área.</p></div>
+      <div><span className="eyebrow">PLANIFICACIÓN OPERATIVA</span><h1>Verificaciones de hallazgos</h1><p>Convertí una fecha de control técnico en una inspección de campo, agrupando Hallazgos de una misma empresa y área.</p></div>
       <Link className="button secondary" to="/hallazgos"><Icon name="chevron" />Volver a hallazgos</Link>
     </div>
 
-    <div className="temporal-notice"><Icon name="calendar" /><p><strong>La fecha de verificación no es el vencimiento administrativo.</strong> Acá sólo aparecen hallazgos que ya recibieron respuesta de la empresa y tienen una fecha de control definida.</p></div>
+    <div className="temporal-notice"><Icon name="calendar" /><p><strong>La verificación es un circuito técnico independiente.</strong> Acá aparecen Hallazgos abiertos con fecha de control definida. Las respuestas y presentaciones administrativas de la empresa se registran en el seguimiento del INF.</p></div>
 
     <div className="finding-attention-grid verification-metrics">
       <button type="button" className={planningStatus === 'UNPLANNED' && !dueFrom && !dueTo ? 'active' : ''} onClick={() => setPlanningView('UNPLANNED')}><small>SIN VISITA</small><strong>{counters.unplanned}</strong><span>{counters.overdueUnplanned} vencidos</span></button>
@@ -205,7 +205,7 @@ export function VerificationPlanningPage() {
 
     {error && <Alert>{error}</Alert>}
     {success && <Alert type="success">{success}</Alert>}
-    {loading ? <LoadingBlock label="Cargando verificaciones…" /> : items.length === 0 ? <EmptyState title="Sin verificaciones en esta vista" text="No hay hallazgos que coincidan con el filtro seleccionado." /> : <div className="table-panel verification-planning-table">
+    {loading ? <LoadingBlock label="Cargando verificaciones…" /> : items.length === 0 ? <EmptyState title="Sin verificaciones en esta vista" text="No hay Hallazgos abiertos con fecha de control que coincidan con el filtro seleccionado." /> : <div className="table-panel verification-planning-table">
       <div className="table-summary"><strong>{meta.total} hallazgo{meta.total === 1 ? '' : 's'}</strong><span>Seleccioná únicamente registros de una misma empresa y área</span></div>
       <div className="table-scroll"><table><thead><tr><th /><th>Hallazgo</th><th>Empresa / área</th><th>Elemento</th><th>Fecha objetivo</th><th>Planificación</th><th /></tr></thead><tbody>{items.map((item) => {
         const key = groupKey(item);
@@ -226,7 +226,7 @@ export function VerificationPlanningPage() {
     </div>}
 
     {planningOpen && <div className="verification-planning-panel panel">
-      <div className="panel-heading"><div><span className="eyebrow">NUEVA VISITA</span><h2>Preparar verificación</h2><p className="section-copy">Se creará una inspección borrador con los elementos seleccionados. Sólo se define la fecha de inicio; el cierre real se registra en campo.</p></div><button type="button" className="icon-button" onClick={() => setPlanningOpen(false)} aria-label="Cerrar">×</button></div>
+      <div className="panel-heading"><div><span className="eyebrow">NUEVA VISITA</span><h2>Preparar verificación</h2><p className="section-copy">Se creará una Inspección borrador con los elementos seleccionados. Sólo se define la fecha de inicio; el cierre real se registra en campo.</p></div><button type="button" className="icon-button" onClick={() => setPlanningOpen(false)} aria-label="Cerrar">×</button></div>
       <div className="verification-context-summary"><div><small>Empresa</small><strong>{selectedCompany?.name}</strong></div><div><small>Área</small><strong>{selectedArea?.name}</strong></div><div><small>Hallazgos</small><strong>{selectedItems.length}</strong></div><div><small>Elementos</small><strong>{new Set(selectedItems.map((item) => item.asset.id)).size}</strong></div></div>
       <form onSubmit={submitPlanning}>
         <div className="form-grid"><label className="field"><span>Fecha y hora de inicio</span><input type="datetime-local" value={plannedStartAt} onChange={(event) => setPlannedStartAt(event.target.value)} required /></label></div>

From bc7cd484367f58276a125a1ede701538eae62046 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:56:20 -0300
Subject: [PATCH 092/224] F4: align dashboard counters with technical and INF
 workflows

---
 api-v3/src/dashboard/dashboard.service.ts | 99 +++++++++++++----------
 1 file changed, 58 insertions(+), 41 deletions(-)

diff --git a/api-v3/src/dashboard/dashboard.service.ts b/api-v3/src/dashboard/dashboard.service.ts
index 4db8e0a..56e5daa 100644
--- a/api-v3/src/dashboard/dashboard.service.ts
+++ b/api-v3/src/dashboard/dashboard.service.ts
@@ -19,12 +19,12 @@ interface DashboardCountsRow {
   inactiveUsers: number | string;
   activeSessions: number | string;
   openFindings: number | string;
-  awaitingCompanyResponse: number | string;
-  overdueCompanyResponses: number | string;
-  companyResponsesDueNext7Days: number | string;
-  awaitingVerificationSchedule: number | string;
+  findingsWithoutControlDate: number | string;
   overdueControls: number | string;
   controlsNext30Days: number | string;
+  reportsWorking: number | string;
+  reportsOfficialized: number | string;
+  sealedActsWithoutReport: number | string;
 }
 
 export interface DashboardUpcomingControl {
@@ -65,43 +65,54 @@ export class DashboardService {
             SELECT COUNT(*) FROM inspection_findings WHERE status = 'OPEN'
           ) AS "openFindings",
           (
-            SELECT COUNT(*) FROM inspection_findings
-            WHERE status = 'OPEN' AND company_response_received_on IS NULL
-          ) AS "awaitingCompanyResponse",
+            SELECT COUNT(*)
+            FROM inspection_findings finding
+            WHERE finding.status = 'OPEN'
+              AND finding.next_control_on IS NULL
+              AND COALESCE((
+                SELECT verification.outcome
+                FROM inspection_finding_verification_visits verification
+                WHERE verification.finding_id=finding.id AND verification.outcome IS NOT NULL
+                ORDER BY verification.result_recorded_at DESC NULLS LAST, verification.created_at DESC, verification.id DESC
+                LIMIT 1
+              ), '') <> 'RESOLVED'
+          ) AS "findingsWithoutControlDate",
           (
-            SELECT COUNT(*) FROM inspection_findings
-            WHERE status = 'OPEN'
-              AND company_response_received_on IS NULL
-              AND correction_due_on IS NOT NULL
-              AND correction_due_on < (CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date
-          ) AS "overdueCompanyResponses",
-          (
-            SELECT COUNT(*) FROM inspection_findings
-            WHERE status = 'OPEN'
-              AND company_response_received_on IS NULL
-              AND correction_due_on BETWEEN
-                (CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date
-                AND (CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date + 7
-          ) AS "companyResponsesDueNext7Days",
-          (
-            SELECT COUNT(*) FROM inspection_findings
-            WHERE status = 'OPEN'
-              AND company_response_received_on IS NOT NULL
-              AND next_control_on IS NULL
-          ) AS "awaitingVerificationSchedule",
-          (
-            SELECT COUNT(*) FROM inspection_findings
-            WHERE status = 'OPEN'
-              AND company_response_received_on IS NOT NULL
-              AND next_control_on < (CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date
+            SELECT COUNT(*)
+            FROM inspection_findings finding
+            WHERE finding.status = 'OPEN'
+              AND finding.next_control_on < (CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date
+              AND COALESCE((
+                SELECT verification.outcome
+                FROM inspection_finding_verification_visits verification
+                WHERE verification.finding_id=finding.id AND verification.outcome IS NOT NULL
+                ORDER BY verification.result_recorded_at DESC NULLS LAST, verification.created_at DESC, verification.id DESC
+                LIMIT 1
+              ), '') <> 'RESOLVED'
           ) AS "overdueControls",
           (
-            SELECT COUNT(*) FROM inspection_findings
-            WHERE status = 'OPEN'
-              AND next_control_on BETWEEN
+            SELECT COUNT(*)
+            FROM inspection_findings finding
+            WHERE finding.status = 'OPEN'
+              AND finding.next_control_on BETWEEN
                 (CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date
                 AND (CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date + 30
-          ) AS "controlsNext30Days"
+              AND COALESCE((
+                SELECT verification.outcome
+                FROM inspection_finding_verification_visits verification
+                WHERE verification.finding_id=finding.id AND verification.outcome IS NOT NULL
+                ORDER BY verification.result_recorded_at DESC NULLS LAST, verification.created_at DESC, verification.id DESC
+                LIMIT 1
+              ), '') <> 'RESOLVED'
+          ) AS "controlsNext30Days",
+          (SELECT COUNT(*) FROM inspection_reports WHERE status='WORKING') AS "reportsWorking",
+          (SELECT COUNT(*) FROM inspection_reports WHERE status='OFFICIALIZED') AS "reportsOfficialized",
+          (
+            SELECT COUNT(*)
+            FROM inspection_acts act
+            WHERE act.status='SEALED'
+              AND NOT EXISTS (SELECT 1 FROM inspection_reports report WHERE report.act_id=act.id)
+          ) AS "sealedActsWithoutReport"
       `)) as DashboardCountsRow[];
 
       const recentAudit = (await manager.query(`
@@ -135,8 +146,14 @@ export class DashboardService {
         INNER JOIN inspection_visits visit ON visit.id = act.visit_id
         INNER JOIN assets asset ON asset.id = finding.asset_id
         WHERE finding.status = 'OPEN'
-          AND finding.company_response_received_on IS NOT NULL
           AND finding.next_control_on IS NOT NULL
+          AND COALESCE((
+            SELECT verification.outcome
+            FROM inspection_finding_verification_visits verification
+            WHERE verification.finding_id=finding.id AND verification.outcome IS NOT NULL
+            ORDER BY verification.result_recorded_at DESC NULLS LAST, verification.created_at DESC, verification.id DESC
+            LIMIT 1
+          ), '') <> 'RESOLVED'
         ORDER BY finding.next_control_on, finding.code
         LIMIT 8
       `)) as DashboardUpcomingControl[];
@@ -151,12 +168,12 @@ export class DashboardService {
           inactiveUsers: Number(counts?.inactiveUsers ?? 0),
           activeSessions: Number(counts?.activeSessions ?? 0),
           openFindings: Number(counts?.openFindings ?? 0),
-          awaitingCompanyResponse: Number(counts?.awaitingCompanyResponse ?? 0),
-          overdueCompanyResponses: Number(counts?.overdueCompanyResponses ?? 0),
-          companyResponsesDueNext7Days: Number(counts?.companyResponsesDueNext7Days ?? 0),
-          awaitingVerificationSchedule: Number(counts?.awaitingVerificationSchedule ?? 0),
+          findingsWithoutControlDate: Number(counts?.findingsWithoutControlDate ?? 0),
           overdueControls: Number(counts?.overdueControls ?? 0),
           controlsNext30Days: Number(counts?.controlsNext30Days ?? 0),
+          reportsWorking: Number(counts?.reportsWorking ?? 0),
+          reportsOfficialized: Number(counts?.reportsOfficialized ?? 0),
+          sealedActsWithoutReport: Number(counts?.sealedActsWithoutReport ?? 0),
         },
         recentAudit,
         upcomingControls,

From c999354645a55b9de9513e342fdd373e94a206e5 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:56:33 -0300
Subject: [PATCH 093/224] F4: add dashboard contract without finding response
 states

---
 web-v2/src/lib/dashboardF4Api.ts | 46 ++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 web-v2/src/lib/dashboardF4Api.ts

diff --git a/web-v2/src/lib/dashboardF4Api.ts b/web-v2/src/lib/dashboardF4Api.ts
new file mode 100644
index 0000000..276815e
--- /dev/null
+++ b/web-v2/src/lib/dashboardF4Api.ts
@@ -0,0 +1,46 @@
+import { apiRequest } from './api';
+
+export interface DashboardSummaryF4 {
+  counts: {
+    totalAssets: number;
+    assetsNeedValidation: number;
+    assetsWithoutGeometry: number;
+    plannedInspections: number;
+    activeUsers: number;
+    inactiveUsers: number;
+    activeSessions: number;
+    openFindings: number;
+    findingsWithoutControlDate: number;
+    overdueControls: number;
+    controlsNext30Days: number;
+    reportsWorking: number;
+    reportsOfficialized: number;
+    sealedActsWithoutReport: number;
+  };
+  recentAudit: Array<{
+    id: string;
+    occurredAt: string;
+    actorUsername: string | null;
+    action: string;
+    entityType: string | null;
+    entityId: string | null;
+  }>;
+  upcomingControls: Array<{
+    id: string;
+    code: string;
+    title: string;
+    nextControlOn: string;
+    actId: string;
+    actCode: string;
+    visitId: string;
+    visitCode: string;
+    assetId: string;
+    assetCode: string;
+    assetName: string;
+  }>;
+  generatedAt: string;
+}
+
+export function getDashboardSummaryF4() {
+  return apiRequest<DashboardSummaryF4>('/dashboard/summary');
+}

From 7a910d750503797528c9087a853b73a55822c042 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:57:00 -0300
Subject: [PATCH 094/224] F4: align dashboard with technical findings and INF
 workflow

---
 web-v2/src/pages/DashboardPage.tsx | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/web-v2/src/pages/DashboardPage.tsx b/web-v2/src/pages/DashboardPage.tsx
index 0c25a26..6964149 100644
--- a/web-v2/src/pages/DashboardPage.tsx
+++ b/web-v2/src/pages/DashboardPage.tsx
@@ -3,8 +3,10 @@ import { Link } from 'react-router';
 import { useAuth } from '../auth/AuthContext';
 import { Alert, LoadingBlock, errorMessage } from '../components/Feedback';
 import { Icon } from '../components/Icon';
-import { getDashboardSummary, getHealth } from '../lib/api';
-import type { DashboardSummary, HealthResponse } from '../lib/api';
+import { getHealth } from '../lib/api';
+import type { HealthResponse } from '../lib/api';
+import { getDashboardSummaryF4 } from '../lib/dashboardF4Api';
+import type { DashboardSummaryF4 } from '../lib/dashboardF4Api';
 import { actionLabel, formatDate, formatDateOnly } from '../lib/format';
 
 function todayDate(): string {
@@ -15,19 +17,19 @@ function todayDate(): string {
 
 export function DashboardPage() {
   const { user, hasPermission } = useAuth();
-  const [summary, setSummary] = useState<DashboardSummary | null>(null);
+  const [summary, setSummary] = useState<DashboardSummaryF4 | null>(null);
   const [health, setHealth] = useState<HealthResponse | null>(null);
   const [error, setError] = useState('');
 
   useEffect(() => {
-    Promise.all([getDashboardSummary(), getHealth()])
+    Promise.all([getDashboardSummaryF4(), getHealth()])
       .then(([dashboard, service]) => { setSummary(dashboard); setHealth(service); })
       .catch((requestError) => setError(errorMessage(requestError)));
   }, []);
 
   return <section>
     <div className="page-heading dashboard-heading">
-      <div><span className="eyebrow">RESUMEN OPERATIVO</span><h1>Buen día, {user?.firstName}</h1><p>Lo que requiere atención y las próximas tareas de inspección.</p></div>
+      <div><span className="eyebrow">RESUMEN OPERATIVO</span><h1>Buen día, {user?.firstName}</h1><p>Lo que requiere atención en Inspecciones, Hallazgos, verificaciones e Informes.</p></div>
       <span className={`health-pill ${health?.status === 'ok' ? 'ok' : ''}`}><span />{health?.status === 'ok' ? 'Sistema operativo' : 'Verificando sistema'}</span>
     </div>
 
@@ -37,23 +39,23 @@ export function DashboardPage() {
       <div className="stat-grid operational-stat-grid">
         <Link className="stat-card" to="/inspecciones?status=PLANNED"><div className="stat-icon blue"><Icon name="calendar" /></div><div><small>INSPECCIONES PLANIFICADAS</small><strong>{summary.counts.plannedInspections}</strong><span>Pendientes de iniciar</span></div></Link>
         <Link className="stat-card" to="/hallazgos?workflow=VERIFICATION_OVERDUE"><div className="stat-icon danger"><Icon name="alert" /></div><div><small>VERIFICACIONES VENCIDAS</small><strong>{summary.counts.overdueControls}</strong><span>Requieren control operativo</span></div></Link>
-        <Link className="stat-card" to="/hallazgos"><div className="stat-icon observed"><Icon name="alert" /></div><div><small>HALLAZGOS ABIERTOS</small><strong>{summary.counts.openFindings}</strong><span>Seguimiento activo</span></div></Link>
-        <Link className="stat-card" to="/inventarios?quick=validation"><div className="stat-icon violet"><Icon name="layers" /></div><div><small>REGISTROS A VALIDAR</small><strong>{summary.counts.assetsNeedValidation}</strong><span>Datos pendientes de revisión</span></div></Link>
+        <Link className="stat-card" to="/hallazgos"><div className="stat-icon observed"><Icon name="alert" /></div><div><small>HALLAZGOS ABIERTOS</small><strong>{summary.counts.openFindings}</strong><span>Seguimiento técnico activo</span></div></Link>
+        <Link className="stat-card" to="/informes?view=pending"><div className="stat-icon violet"><Icon name="clipboard" /></div><div><small>ACTAS SIN INF</small><strong>{summary.counts.sealedActsWithoutReport}</strong><span>Actas selladas pendientes de Informe</span></div></Link>
       </div>
 
-      <div className="dashboard-section-heading compact"><div><span className="eyebrow">INVENTARIOS Y SEGUIMIENTO</span><h2>Estado general</h2></div></div>
+      <div className="dashboard-section-heading compact"><div><span className="eyebrow">INVENTARIOS Y DOCUMENTOS</span><h2>Estado general</h2></div></div>
       <div className="stat-grid secondary-stat-grid">
-        <Link className="stat-card compact" to="/inventarios"><div className="stat-icon blue"><Icon name="layers" /></div><div><small>INVENTARIO</small><strong>{summary.counts.totalAssets}</strong><span>Elementos registrados en los inventarios</span></div></Link>
+        <Link className="stat-card compact" to="/inventarios"><div className="stat-icon blue"><Icon name="layers" /></div><div><small>INVENTARIO</small><strong>{summary.counts.totalAssets}</strong><span>Elementos registrados</span></div></Link>
         <Link className="stat-card compact" to="/inventarios?quick=location"><div className="stat-icon gray"><Icon name="map" /></div><div><small>SIN UBICACIÓN</small><strong>{summary.counts.assetsWithoutGeometry}</strong><span>Sin geometría registrada</span></div></Link>
-        <Link className="stat-card compact" to="/hallazgos?workflow=WAITING_COMPANY"><div className="stat-icon gray"><Icon name="clipboard" /></div><div><small>ESPERANDO RESPUESTA</small><strong>{summary.counts.awaitingCompanyResponse}</strong><span>{summary.counts.overdueCompanyResponses} vencidas · {summary.counts.companyResponsesDueNext7Days} vencen en 7 días</span></div></Link>
-        <Link className="stat-card compact" to="/hallazgos?workflow=TO_VERIFY"><div className="stat-icon green"><Icon name="calendar" /></div><div><small>PRÓXIMAS VERIFICACIONES</small><strong>{summary.counts.controlsNext30Days}</strong><span>{summary.counts.awaitingVerificationSchedule} pendientes de programar</span></div></Link>
+        <Link className="stat-card compact" to="/informes"><div className="stat-icon gray"><Icon name="audit" /></div><div><small>INF EN PREPARACIÓN</small><strong>{summary.counts.reportsWorking}</strong><span>{summary.counts.reportsOfficialized} oficializados en GEDO</span></div></Link>
+        <Link className="stat-card compact" to="/hallazgos/planificacion"><div className="stat-icon green"><Icon name="calendar" /></div><div><small>PRÓXIMAS VERIFICACIONES</small><strong>{summary.counts.controlsNext30Days}</strong><span>{summary.counts.findingsWithoutControlDate} Hallazgos abiertos sin fecha de control</span></div></Link>
       </div>
 
       {hasPermission('inspection_findings.read') && <article className="panel upcoming-controls-panel">
-        <div className="panel-heading"><div><span className="eyebrow">AGENDA</span><h2>Próximos controles</h2><p className="section-copy">Hallazgos que tienen una fecha de verificación programada.</p></div><Link className="text-link" to="/hallazgos">Ver hallazgos <Icon name="chevron" size={15} /></Link></div>
+        <div className="panel-heading"><div><span className="eyebrow">AGENDA</span><h2>Próximos controles</h2><p className="section-copy">Hallazgos abiertos con una fecha de verificación definida.</p></div><Link className="text-link" to="/hallazgos/planificacion">Planificar verificaciones <Icon name="chevron" size={15} /></Link></div>
         <div className="activity-list">
           {summary.upcomingControls.length === 0 && <p className="muted">Todavía no hay controles programados.</p>}
-          {summary.upcomingControls.map((control) => <Link className="activity-item control-item" key={control.id} to={`/inspecciones/actas/${control.actId}`}><span className={`activity-dot ${control.nextControlOn < todayDate() ? 'overdue-dot' : ''}`} /><div><strong>{control.title}</strong><p>{control.assetCode} · {control.assetName}</p></div><time>{formatDateOnly(control.nextControlOn)}</time></Link>)}
+          {summary.upcomingControls.map((control) => <Link className="activity-item control-item" key={control.id} to={`/hallazgos/${control.id}`}><span className={`activity-dot ${control.nextControlOn < todayDate() ? 'overdue-dot' : ''}`} /><div><strong>{control.title}</strong><p>{control.assetCode} · {control.assetName} · {control.actCode}</p></div><time>{formatDateOnly(control.nextControlOn)}</time></Link>)}
         </div>
       </article>}
 
@@ -66,7 +68,7 @@ export function DashboardPage() {
         <article className="panel quick-panel">
           <span className="eyebrow">ACCESOS RÁPIDOS</span><h2>Administración</h2>
           <div className="quick-links">
-            <Link to="/inventarios"><Icon name="layers" /><span><strong>Inventarios</strong><small>Inventario operativo organizado por empresa</small></span><Icon name="chevron" /></Link>
+            <Link to="/inventarios"><Icon name="layers" /><span><strong>Inventarios</strong><small>Inventario operativo organizado por empresa y área</small></span><Icon name="chevron" /></Link>
             {hasPermission('asset_types.read') && <Link to="/admin/asset-types"><Icon name="layers" /><span><strong>Configuración de Inventarios</strong><small>Tipos y campos configurables</small></span><Icon name="chevron" /></Link>}
             {hasPermission('users.read') && <Link to="/admin/users"><Icon name="users" /><span><strong>Usuarios</strong><small>Accesos y roles</small></span><Icon name="chevron" /></Link>}
           </div>

From 4db3797afc2d5820b8456372ed2caa4ac1a08e1f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:58:32 -0300
Subject: [PATCH 095/224] F4: add technical finding worklist service

---
 .../inspection-finding-worklist.service.ts    | 333 ++++++++++++++++++
 1 file changed, 333 insertions(+)
 create mode 100644 api-v3/src/inspection-findings/inspection-finding-worklist.service.ts

diff --git a/api-v3/src/inspection-findings/inspection-finding-worklist.service.ts b/api-v3/src/inspection-findings/inspection-finding-worklist.service.ts
new file mode 100644
index 0000000..0838a2d
--- /dev/null
+++ b/api-v3/src/inspection-findings/inspection-finding-worklist.service.ts
@@ -0,0 +1,333 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import type { ListInspectionFindingsQueryDto } from './dto/list-inspection-findings-query.dto';
+
+export interface InspectionFindingWorklistCounters {
+  open: number;
+  withoutControlDate: number;
+  toVerify: number;
+  verificationOverdue: number;
+  verificationNext30Days: number;
+  readyToClose: number;
+  closed: number;
+}
+
+export interface InspectionFindingWorklistItem {
+  id: string;
+  actId: string;
+  assetId: string;
+  code: string;
+  status: 'OPEN' | 'CLOSED' | 'VOIDED';
+  title: string;
+  description: string;
+  severity: number | null;
+  nextControlOn: string | null;
+  closedAt: Date | null;
+  closureNotes: string | null;
+  asset: {
+    id: string;
+    code: string;
+    name: string;
+    commonName: string | null;
+    typeName: string;
+    operatorCompany: { id: string; code: string; name: string } | null;
+    operationalArea: { id: string; code: string; name: string } | null;
+  };
+  document: {
+    actId: string;
+    actCode: string;
+    actStatus: string;
+    visitId: string;
+    visitCode: string;
+    visitStatus: string;
+  };
+  verificationVisit: {
+    id: string;
+    code: string;
+    title: string;
+    status: string;
+    plannedStartAt: Date | null;
+  } | null;
+  latestVerification: {
+    visitId: string;
+    visitCode: string;
+    visitStatus: string;
+    targetControlOn: string | null;
+    outcome: 'RESOLVED' | 'NOT_RESOLVED' | 'REQUIRES_NEW_DATE' | null;
+    resultNotes: string | null;
+    verifiedAt: Date | null;
+    resultRecordedAt: Date | null;
+    rescheduledControlOn: string | null;
+    evidenceCount: number;
+  } | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface InspectionFindingWorklistPage {
+  data: InspectionFindingWorklistItem[];
+  meta: { page: number; pageSize: number; total: number; totalPages: number };
+  counters: InspectionFindingWorklistCounters;
+}
+
+@Injectable()
+export class InspectionFindingWorklistService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async list(query: ListInspectionFindingsQueryDto): Promise<InspectionFindingWorklistPage> {
+    const page = query.page ?? 1;
+    const pageSize = query.pageSize ?? 25;
+    const workflow = query.workflow ?? 'OPEN';
+    const values: unknown[] = [];
+    const contextFilters: string[] = [];
+    const today = `(CURRENT_TIMESTAMP AT TIME ZONE 'America/Argentina/Mendoza')::date`;
+    const latestOutcome = `(SELECT latest_verification.outcome
+      FROM inspection_finding_verification_visits latest_verification
+      WHERE latest_verification.finding_id = finding.id
+        AND latest_verification.outcome IS NOT NULL
+      ORDER BY latest_verification.result_recorded_at DESC NULLS LAST,
+               latest_verification.created_at DESC,
+               latest_verification.id DESC
+      LIMIT 1)`;
+    const latestVisitStatus = `(SELECT latest_visit.status
+      FROM inspection_finding_verification_visits latest_verification
+      INNER JOIN inspection_visits latest_visit ON latest_visit.id = latest_verification.visit_id
+      WHERE latest_verification.finding_id = finding.id
+        AND latest_verification.outcome IS NOT NULL
+      ORDER BY latest_verification.result_recorded_at DESC NULLS LAST,
+               latest_verification.created_at DESC,
+               latest_verification.id DESC
+      LIMIT 1)`;
+
+    const add = (value: unknown): string => {
+      values.push(value);
+      return `$${values.length}`;
+    };
+
+    if (query.search) {
+      const parameter = add(`%${query.search}%`);
+      contextFilters.push(`(
+        finding.code ILIKE ${parameter}
+        OR finding.title ILIKE ${parameter}
+        OR finding.description ILIKE ${parameter}
+        OR asset.code ILIKE ${parameter}
+        OR asset.name ILIKE ${parameter}
+        OR company.name ILIKE ${parameter}
+        OR area.name ILIKE ${parameter}
+        OR act.code ILIKE ${parameter}
+      )`);
+    }
+    if (query.companyId) contextFilters.push(`company.id = ${add(query.companyId)}::uuid`);
+    if (query.areaId) contextFilters.push(`area.id = ${add(query.areaId)}::uuid`);
+    if (query.inspectorId) {
+      const inspector = add(query.inspectorId);
+      contextFilters.push(`(
+        visit.lead_inspector_user_id = ${inspector}::uuid
+        OR EXISTS (
+          SELECT 1 FROM inspection_visit_members member_filter
+          WHERE member_filter.visit_id = visit.id
+            AND member_filter.included = true
+            AND member_filter.user_id = ${inspector}::uuid
+        )
+      )`);
+    }
+    if (query.dateFrom) contextFilters.push(`act.occurred_at::date >= ${add(query.dateFrom)}::date`);
+    if (query.dateTo) contextFilters.push(`act.occurred_at::date <= ${add(query.dateTo)}::date`);
+
+    const workflowFilters: string[] = [];
+    if (workflow === 'OPEN') workflowFilters.push(`finding.status = 'OPEN'`);
+    if (workflow === 'TO_SCHEDULE_VERIFICATION') {
+      workflowFilters.push(`finding.status = 'OPEN' AND finding.next_control_on IS NULL AND COALESCE(${latestOutcome}, '') <> 'RESOLVED'`);
+    }
+    if (workflow === 'TO_VERIFY') {
+      workflowFilters.push(`finding.status = 'OPEN' AND finding.next_control_on IS NOT NULL AND COALESCE(${latestOutcome}, '') <> 'RESOLVED'`);
+    }
+    if (workflow === 'VERIFICATION_OVERDUE') {
+      workflowFilters.push(`finding.status = 'OPEN' AND finding.next_control_on IS NOT NULL AND finding.next_control_on < ${today} AND COALESCE(${latestOutcome}, '') <> 'RESOLVED'`);
+    }
+    if (workflow === 'READY_TO_CLOSE') {
+      workflowFilters.push(`finding.status = 'OPEN' AND ${latestOutcome} = 'RESOLVED' AND ${latestVisitStatus} = 'CLOSED'`);
+    }
+    if (workflow === 'CLOSED') workflowFilters.push(`finding.status = 'CLOSED'`);
+    if (workflow === 'WAITING_COMPANY' || workflow === 'COMPANY_OVERDUE') {
+      // Compatibilidad de URL histórica: estos estados dejaron de existir en F4.
+      workflowFilters.push(`finding.status = 'OPEN'`);
+    }
+
+    const joins = `
+      INNER JOIN inspection_acts act ON act.id = finding.act_id
+      INNER JOIN inspection_visits visit ON visit.id = act.visit_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 assets company ON company.id = asset.operator_company_id
+      LEFT JOIN assets area ON area.id = asset.operational_area_id
+    `;
+    const filters = [...contextFilters, ...workflowFilters];
+    const where = filters.length ? `WHERE ${filters.join(' AND ')}` : '';
+    const contextWhere = contextFilters.length ? `WHERE ${contextFilters.join(' AND ')}` : '';
+
+    const [countRow] = await this.dataSource.query(`
+      SELECT COUNT(*)::integer AS total
+      FROM inspection_findings finding
+      ${joins}
+      ${where}
+    `, values) as Array<{ total: number }>;
+    const total = Number(countRow?.total ?? 0);
+
+    const listValues = [...values, pageSize, (page - 1) * pageSize];
+    const limitParameter = `$${values.length + 1}`;
+    const offsetParameter = `$${values.length + 2}`;
+    const data = await this.dataSource.query(`
+      SELECT
+        finding.id,
+        finding.act_id AS "actId",
+        finding.asset_id AS "assetId",
+        finding.code,
+        finding.status,
+        finding.title,
+        finding.description,
+        finding.severity,
+        finding.next_control_on AS "nextControlOn",
+        finding.closed_at AS "closedAt",
+        finding.closure_notes AS "closureNotes",
+        JSONB_BUILD_OBJECT(
+          'id', asset.id,
+          'code', asset.code,
+          'name', asset.name,
+          'commonName', asset.common_name,
+          'typeName', asset_type.name,
+          'operatorCompany', CASE WHEN company.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
+            'id', company.id, 'code', company.code, 'name', company.name
+          ) END,
+          'operationalArea', CASE WHEN area.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
+            'id', area.id, 'code', area.code, 'name', area.name
+          ) END
+        ) AS asset,
+        JSONB_BUILD_OBJECT(
+          'actId', act.id,
+          'actCode', act.code,
+          'actStatus', act.status,
+          'visitId', visit.id,
+          'visitCode', visit.code,
+          'visitStatus', visit.status
+        ) AS document,
+        CASE WHEN verification_visit.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
+          'id', verification_visit.id,
+          'code', verification_visit.code,
+          'title', verification_visit.title,
+          'status', verification_visit.status,
+          'plannedStartAt', verification_visit.planned_start_at
+        ) END AS "verificationVisit",
+        CASE WHEN latest_verification.visit_id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
+          'visitId', latest_verification.visit_id,
+          'visitCode', latest_verification.visit_code,
+          'visitStatus', latest_verification.visit_status,
+          'targetControlOn', latest_verification.target_control_on,
+          'outcome', latest_verification.outcome,
+          'resultNotes', latest_verification.result_notes,
+          'verifiedAt', latest_verification.verified_at,
+          'resultRecordedAt', latest_verification.result_recorded_at,
+          'rescheduledControlOn', latest_verification.rescheduled_control_on,
+          'evidenceCount', latest_verification.evidence_count
+        ) END AS "latestVerification",
+        finding.created_at AS "createdAt",
+        finding.updated_at AS "updatedAt"
+      FROM inspection_findings finding
+      ${joins}
+      LEFT JOIN LATERAL (
+        SELECT verification_target.id, verification_target.code, verification_target.title,
+          verification_target.status, verification_target.planned_start_at
+        FROM inspection_finding_verification_visits verification_link
+        INNER JOIN inspection_visits verification_target ON verification_target.id = verification_link.visit_id
+        WHERE verification_link.finding_id = finding.id
+          AND verification_target.status IN ('DRAFT', 'PLANNED', 'IN_PROGRESS')
+        ORDER BY verification_link.created_at DESC, verification_link.id DESC
+        LIMIT 1
+      ) verification_visit ON true
+      LEFT JOIN LATERAL (
+        SELECT
+          verification_link.visit_id,
+          verification_target.code AS visit_code,
+          verification_target.status AS visit_status,
+          verification_link.target_control_on,
+          verification_link.outcome,
+          verification_link.result_notes,
+          verification_link.verified_at,
+          verification_link.result_recorded_at,
+          verification_link.rescheduled_control_on,
+          (SELECT COUNT(*)::integer
+           FROM inspection_finding_evidence evidence
+           WHERE evidence.finding_id = finding.id
+             AND evidence.verification_visit_id = verification_link.visit_id
+             AND evidence.purpose = 'VERIFICATION') AS evidence_count
+        FROM inspection_finding_verification_visits verification_link
+        INNER JOIN inspection_visits verification_target ON verification_target.id = verification_link.visit_id
+        WHERE verification_link.finding_id = finding.id
+        ORDER BY COALESCE(verification_link.result_recorded_at, verification_link.created_at) DESC,
+                 verification_link.id DESC
+        LIMIT 1
+      ) latest_verification ON true
+      ${where}
+      ORDER BY
+        CASE WHEN finding.status = 'OPEN' THEN 0 ELSE 1 END,
+        COALESCE(finding.next_control_on, '9999-12-31'::date),
+        finding.updated_at DESC,
+        finding.code
+      LIMIT ${limitParameter} OFFSET ${offsetParameter}
+    `, listValues) as InspectionFindingWorklistItem[];
+
+    const [counterRow] = await this.dataSource.query(`
+      SELECT
+        COUNT(*) FILTER (WHERE finding.status='OPEN')::integer AS "open",
+        COUNT(*) FILTER (
+          WHERE finding.status='OPEN'
+            AND finding.next_control_on IS NULL
+            AND COALESCE(${latestOutcome}, '') <> 'RESOLVED'
+        )::integer AS "withoutControlDate",
+        COUNT(*) FILTER (
+          WHERE finding.status='OPEN'
+            AND finding.next_control_on IS NOT NULL
+            AND COALESCE(${latestOutcome}, '') <> 'RESOLVED'
+        )::integer AS "toVerify",
+        COUNT(*) FILTER (
+          WHERE finding.status='OPEN'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on < ${today}
+            AND COALESCE(${latestOutcome}, '') <> 'RESOLVED'
+        )::integer AS "verificationOverdue",
+        COUNT(*) FILTER (
+          WHERE finding.status='OPEN'
+            AND finding.next_control_on BETWEEN ${today} AND ${today} + 30
+            AND COALESCE(${latestOutcome}, '') <> 'RESOLVED'
+        )::integer AS "verificationNext30Days",
+        COUNT(*) FILTER (
+          WHERE finding.status='OPEN'
+            AND ${latestOutcome}='RESOLVED'
+            AND ${latestVisitStatus}='CLOSED'
+        )::integer AS "readyToClose",
+        COUNT(*) FILTER (WHERE finding.status='CLOSED')::integer AS "closed"
+      FROM inspection_findings finding
+      ${joins}
+      ${contextWhere}
+    `, values) as InspectionFindingWorklistCounters[];
+
+    return {
+      data,
+      meta: {
+        page,
+        pageSize,
+        total,
+        totalPages: total === 0 ? 0 : Math.ceil(total / pageSize),
+      },
+      counters: {
+        open: Number(counterRow?.open ?? 0),
+        withoutControlDate: Number(counterRow?.withoutControlDate ?? 0),
+        toVerify: Number(counterRow?.toVerify ?? 0),
+        verificationOverdue: Number(counterRow?.verificationOverdue ?? 0),
+        verificationNext30Days: Number(counterRow?.verificationNext30Days ?? 0),
+        readyToClose: Number(counterRow?.readyToClose ?? 0),
+        closed: Number(counterRow?.closed ?? 0),
+      },
+    };
+  }
+}

From 1192ed2cddd03f0efae3bbd65ea4d8ec883766e8 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:58:49 -0300
Subject: [PATCH 096/224] F4: route global findings to technical worklist

---
 .../inspection-findings/inspection-findings.controller.ts | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/api-v3/src/inspection-findings/inspection-findings.controller.ts b/api-v3/src/inspection-findings/inspection-findings.controller.ts
index ce33ffe..6e1d522 100644
--- a/api-v3/src/inspection-findings/inspection-findings.controller.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.controller.ts
@@ -16,6 +16,7 @@ import { CloseInspectionFindingDto } from './dto/close-inspection-finding.dto';
 import { CreateInspectionFindingDto } from './dto/create-inspection-finding.dto';
 import { ListInspectionFindingsQueryDto } from './dto/list-inspection-findings-query.dto';
 import { UpdateInspectionFindingDto } from './dto/update-inspection-finding.dto';
+import { InspectionFindingWorklistService } from './inspection-finding-worklist.service';
 import { InspectionFindingsService } from './inspection-findings.service';
 
 @Controller('inspection-acts/:actId/findings')
@@ -42,12 +43,15 @@ export class InspectionActFindingsController {
 
 @Controller('inspection-findings')
 export class InspectionFindingsController {
-  constructor(private readonly findings: InspectionFindingsService) {}
+  constructor(
+    private readonly findings: InspectionFindingsService,
+    private readonly worklist: InspectionFindingWorklistService,
+  ) {}
 
   @Get()
   @RequirePermissions('inspection_findings.read')
   list(@Query() query: ListInspectionFindingsQueryDto) {
-    return this.findings.listGlobal(query);
+    return this.worklist.list(query);
   }
 
   @Get(':id')

From 2e5c4c35aa7aafcbfd4377d15ac29a3df1ccca8f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:59:03 -0300
Subject: [PATCH 097/224] F4: register technical findings worklist

---
 api-v3/src/inspection-findings/inspection-findings.module.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/api-v3/src/inspection-findings/inspection-findings.module.ts b/api-v3/src/inspection-findings/inspection-findings.module.ts
index de913ca..8c47882 100644
--- a/api-v3/src/inspection-findings/inspection-findings.module.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.module.ts
@@ -6,6 +6,7 @@ import { FindingCatalogService } from './finding-catalog.service';
 import { F3FindingCatalogResolverService } from './f3-finding-catalog-resolver.service';
 import { FindingRecurrenceController } from './finding-recurrence.controller';
 import { FindingRecurrenceService } from './finding-recurrence.service';
+import { InspectionFindingWorklistService } from './inspection-finding-worklist.service';
 import {
   InspectionActFindingsController,
   InspectionFindingsController,
@@ -34,6 +35,7 @@ import { InspectionEvidenceService } from './inspection-evidence.service';
     F3FindingCatalogResolverService,
     FindingCatalogMergeService,
     InspectionFindingsService,
+    InspectionFindingWorklistService,
     FindingRecurrenceService,
     InspectionEvidenceService,
   ],
@@ -42,6 +44,7 @@ import { InspectionEvidenceService } from './inspection-evidence.service';
     F3FindingCatalogResolverService,
     FindingCatalogMergeService,
     InspectionFindingsService,
+    InspectionFindingWorklistService,
     FindingRecurrenceService,
   ],
 })

From 92cf0dee97091f1dad9021518d87590cd280884a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 22:59:24 -0300
Subject: [PATCH 098/224] F4: add technical findings worklist client

---
 web-v2/src/lib/findingWorklistF4Api.ts | 96 ++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)
 create mode 100644 web-v2/src/lib/findingWorklistF4Api.ts

diff --git a/web-v2/src/lib/findingWorklistF4Api.ts b/web-v2/src/lib/findingWorklistF4Api.ts
new file mode 100644
index 0000000..abe1491
--- /dev/null
+++ b/web-v2/src/lib/findingWorklistF4Api.ts
@@ -0,0 +1,96 @@
+import { apiRequest } from './api';
+
+export type FindingWorklistWorkflowF4 =
+  | 'OPEN'
+  | 'TO_SCHEDULE_VERIFICATION'
+  | 'TO_VERIFY'
+  | 'VERIFICATION_OVERDUE'
+  | 'READY_TO_CLOSE'
+  | 'CLOSED'
+  | 'ALL';
+
+export interface FindingWorklistItemF4 {
+  id: string;
+  actId: string;
+  assetId: string;
+  code: string;
+  status: 'OPEN' | 'CLOSED' | 'VOIDED';
+  title: string;
+  description: string;
+  severity: number | null;
+  nextControlOn: string | null;
+  closedAt: string | null;
+  closureNotes: string | null;
+  asset: {
+    id: string;
+    code: string;
+    name: string;
+    commonName: string | null;
+    typeName: string;
+    operatorCompany: { id: string; code: string; name: string } | null;
+    operationalArea: { id: string; code: string; name: string } | null;
+  };
+  document: {
+    actId: string;
+    actCode: string;
+    actStatus: string;
+    visitId: string;
+    visitCode: string;
+    visitStatus: string;
+  };
+  verificationVisit: {
+    id: string;
+    code: string;
+    title: string;
+    status: string;
+    plannedStartAt: string | null;
+  } | null;
+  latestVerification: {
+    visitId: string;
+    visitCode: string;
+    visitStatus: string;
+    targetControlOn: string | null;
+    outcome: 'RESOLVED' | 'NOT_RESOLVED' | 'REQUIRES_NEW_DATE' | null;
+    resultNotes: string | null;
+    verifiedAt: string | null;
+    resultRecordedAt: string | null;
+    rescheduledControlOn: string | null;
+    evidenceCount: number;
+  } | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface FindingWorklistCountersF4 {
+  open: number;
+  withoutControlDate: number;
+  toVerify: number;
+  verificationOverdue: number;
+  verificationNext30Days: number;
+  readyToClose: number;
+  closed: number;
+}
+
+export interface FindingWorklistPageF4 {
+  data: FindingWorklistItemF4[];
+  meta: { page: number; pageSize: number; total: number; totalPages: number };
+  counters: FindingWorklistCountersF4;
+}
+
+export function listFindingWorklistF4(query: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  workflow?: FindingWorklistWorkflowF4;
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+}) {
+  const params = new URLSearchParams();
+  Object.entries(query).forEach(([key, value]) => {
+    if (value !== undefined && value !== '') params.set(key, String(value));
+  });
+  return apiRequest<FindingWorklistPageF4>(`/inspection-findings?${params.toString()}`);
+}

From 1775392eb154e6a078eb095afd1b454e2f62454d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:00:01 -0300
Subject: [PATCH 099/224] F4: make findings worklist technical-only

---
 web-v2/src/pages/FindingsPage.tsx | 129 ++++++++++++++----------------
 1 file changed, 59 insertions(+), 70 deletions(-)

diff --git a/web-v2/src/pages/FindingsPage.tsx b/web-v2/src/pages/FindingsPage.tsx
index 858ee8b..b987118 100644
--- a/web-v2/src/pages/FindingsPage.tsx
+++ b/web-v2/src/pages/FindingsPage.tsx
@@ -7,69 +7,29 @@ import { Alert, EmptyState, LoadingBlock, errorMessage } from '../components/Fee
 import { Icon } from '../components/Icon';
 import { useOperationalContext } from '../context/OperationalContext';
 import { OperationalFilters } from '../features/inspections/OperationalFilters';
-import { listInspectionFindingsGlobal } from '../lib/api';
+import {
+  listFindingWorklistF4,
+} from '../lib/findingWorklistF4Api';
 import type {
-  InspectionFinding,
-  InspectionFindingWorkflow,
-  InspectionFindingWorkflowCounters,
-  PageMeta,
-} from '../lib/api';
+  FindingWorklistCountersF4,
+  FindingWorklistItemF4,
+  FindingWorklistWorkflowF4,
+} from '../lib/findingWorklistF4Api';
 import { formatDateOnly } from '../lib/format';
 
-const workflows: Array<{ value: InspectionFindingWorkflow; label: string }> = [
+const workflows: Array<{ value: FindingWorklistWorkflowF4; label: string }> = [
   { value: 'OPEN', label: 'Abiertos' },
-  { value: 'WAITING_COMPANY', label: 'Esperando empresa' },
-  { value: 'COMPANY_OVERDUE', label: 'Respuesta vencida' },
-  { value: 'TO_SCHEDULE_VERIFICATION', label: 'Programar verificación' },
-  { value: 'TO_VERIFY', label: 'Para verificar' },
+  { value: 'TO_SCHEDULE_VERIFICATION', label: 'Sin fecha de control' },
+  { value: 'TO_VERIFY', label: 'Con control programado' },
   { value: 'VERIFICATION_OVERDUE', label: 'Verificación vencida' },
   { value: 'READY_TO_CLOSE', label: 'Listos para cerrar' },
   { value: 'CLOSED', label: 'Cerrados' },
   { value: 'ALL', label: 'Todos' },
 ];
 
-function todayInput(): string {
-  const now = new Date();
-  const local = new Date(now.getTime() - now.getTimezoneOffset() * 60_000);
-  return local.toISOString().slice(0, 10);
-}
-
-function attentionLabel(finding: InspectionFinding): { label: string; className: string } {
-  const today = todayInput();
-  if (finding.latestVerification?.outcome === 'RESOLVED' && finding.latestVerification.visitStatus === 'CLOSED') return { label: 'Listo para cerrar', className: 'active' };
-  if (finding.status === 'CLOSED') return { label: 'Cerrado', className: 'active' };
-  if (!finding.companyResponseReceivedOn) {
-    if (finding.correctionDueOn && finding.correctionDueOn < today) return { label: 'Respuesta vencida', className: 'danger' };
-    return { label: 'Esperando empresa', className: 'pending' };
-  }
-  if (!finding.nextControlOn) return { label: 'Programar verificación', className: 'observed' };
-  if (finding.nextControlOn < today) return { label: 'Verificación vencida', className: 'danger' };
-  return { label: 'Para verificar', className: 'blue' };
-}
-
-function deadlineText(finding: InspectionFinding): { title: string; value: string | null; overdue: boolean } {
-  const today = todayInput();
-  if (finding.latestVerification?.outcome === 'RESOLVED' && finding.latestVerification.visitStatus === 'CLOSED') return { title: 'Verificado conforme', value: finding.latestVerification.verifiedAt, overdue: false };
-  if (!finding.companyResponseReceivedOn) {
-    return {
-      title: 'Respuesta de empresa',
-      value: finding.correctionDueOn,
-      overdue: Boolean(finding.correctionDueOn && finding.correctionDueOn < today),
-    };
-  }
-  return {
-    title: 'Verificación DH',
-    value: finding.nextControlOn,
-    overdue: Boolean(finding.nextControlOn && finding.nextControlOn < today),
-  };
-}
-
-const emptyCounters: InspectionFindingWorkflowCounters = {
+const emptyCounters: FindingWorklistCountersF4 = {
   open: 0,
-  waitingCompany: 0,
-  companyOverdue: 0,
-  companyDueNext7Days: 0,
-  awaitingVerificationSchedule: 0,
+  withoutControlDate: 0,
   toVerify: 0,
   verificationOverdue: 0,
   verificationNext30Days: 0,
@@ -77,17 +37,47 @@ const emptyCounters: InspectionFindingWorkflowCounters = {
   closed: 0,
 };
 
+function todayInput(): string {
+  const now = new Date();
+  const local = new Date(now.getTime() - now.getTimezoneOffset() * 60_000);
+  return local.toISOString().slice(0, 10);
+}
+
+function attentionLabel(finding: FindingWorklistItemF4): { label: string; className: string } {
+  const today = todayInput();
+  if (finding.status === 'CLOSED') return { label: 'Cerrado', className: 'active' };
+  if (finding.latestVerification?.outcome === 'RESOLVED' && finding.latestVerification.visitStatus === 'CLOSED') {
+    return { label: 'Listo para cerrar', className: 'active' };
+  }
+  if (!finding.nextControlOn) return { label: 'Sin fecha de control', className: 'observed' };
+  if (finding.verificationVisit) return { label: 'Verificación planificada', className: 'blue' };
+  if (finding.nextControlOn < today) return { label: 'Verificación vencida', className: 'danger' };
+  return { label: 'Control programado', className: 'pending' };
+}
+
+function deadlineText(finding: FindingWorklistItemF4): { title: string; value: string | null; overdue: boolean } {
+  const today = todayInput();
+  if (finding.latestVerification?.outcome === 'RESOLVED' && finding.latestVerification.visitStatus === 'CLOSED') {
+    return { title: 'Verificado conforme', value: finding.latestVerification.verifiedAt, overdue: false };
+  }
+  return {
+    title: finding.nextControlOn ? 'Verificación DH' : 'Sin fecha definida',
+    value: finding.nextControlOn,
+    overdue: Boolean(finding.nextControlOn && finding.nextControlOn < today),
+  };
+}
+
 export function FindingsPage() {
   const [params, setParams] = useSearchParams();
   const operationalContext = useOperationalContext();
-  const [items, setItems] = useState<InspectionFinding[]>([]);
-  const [meta, setMeta] = useState<PageMeta>({ page: 1, pageSize: 25, total: 0, totalPages: 0 });
-  const [counters, setCounters] = useState(emptyCounters);
+  const [items, setItems] = useState<FindingWorklistItemF4[]>([]);
+  const [meta, setMeta] = useState({ page: 1, pageSize: 25, total: 0, totalPages: 0 });
+  const [counters, setCounters] = useState<FindingWorklistCountersF4>(emptyCounters);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState('');
   const workflowValue = params.get('workflow') ?? 'OPEN';
   const workflow = workflows.some((item) => item.value === workflowValue)
-    ? workflowValue as InspectionFindingWorkflow
+    ? workflowValue as FindingWorklistWorkflowF4
     : 'OPEN';
   const search = params.get('search') ?? '';
   const [draftSearch, setDraftSearch] = useState(search);
@@ -101,7 +91,7 @@ export function FindingsPage() {
   useEffect(() => {
     setLoading(true);
     setError('');
-    listInspectionFindingsGlobal({ page, pageSize: 25, search, workflow, companyId, areaId, inspectorId, dateFrom, dateTo })
+    listFindingWorklistF4({ page, pageSize: 25, search, workflow, companyId, areaId, inspectorId, dateFrom, dateTo })
       .then((response) => {
         setItems(response.data);
         setMeta(response.meta);
@@ -140,38 +130,37 @@ export function FindingsPage() {
 
   return <section>
     <div className="page-heading">
-      <div><span className="eyebrow">SEGUIMIENTO</span><h1>Hallazgos</h1><p>Bandeja de trabajo para respuestas de empresas, vencimientos, verificaciones y cierres.</p></div>
+      <div><span className="eyebrow">SEGUIMIENTO TÉCNICO</span><h1>Hallazgos</h1><p>Observaciones originales, evidencia, fechas de control, verificaciones y cierre técnico. Las presentaciones administrativas de empresa se siguen desde el INF.</p></div>
       <PermissionGate permission="inspection_verifications.plan"><Link className="button primary" to="/hallazgos/planificacion"><Icon name="calendar" />Planificar verificaciones</Link></PermissionGate>
     </div>
 
     <div className="finding-workflow-explainer">
-      <div><span>1</span><strong>Vencimiento administrativo</strong><small>Fecha límite para recibir la respuesta de la empresa.</small></div>
+      <div><span>1</span><strong>Hallazgo</strong><small>Observación y Descripción registradas en el Acta.</small></div>
       <i>→</i>
-      <div><span>2</span><strong>Respuesta recibida</strong><small>Se carga la presentación y su documentación.</small></div>
+      <div><span>2</span><strong>Fecha de control</strong><small>Se define cuándo corresponde volver a verificar.</small></div>
       <i>→</i>
-      <div><span>3</span><strong>Vencimiento de verificación</strong><small>Fecha para volver a inspeccionar o verificar la solución.</small></div>
+      <div><span>3</span><strong>Verificación</strong><small>El inspector registra el resultado y la evidencia en campo.</small></div>
       <i>→</i>
-      <div><span>4</span><strong>Cierre</strong><small>El hallazgo se cierra cuando la solución queda verificada.</small></div>
+      <div><span>4</span><strong>Cierre</strong><small>Se cierra cuando la solución queda técnicamente verificada.</small></div>
     </div>
 
     <div className="finding-attention-grid">
-      <button type="button" className={workflow === 'WAITING_COMPANY' ? 'active' : ''} onClick={() => setFilter('workflow', 'WAITING_COMPANY')}><small>ESPERANDO EMPRESA</small><strong>{counters.waitingCompany}</strong><span>{counters.companyOverdue} vencidos</span></button>
-      <button type="button" className={workflow === 'COMPANY_OVERDUE' ? 'active danger' : 'danger'} onClick={() => setFilter('workflow', 'COMPANY_OVERDUE')}><small>RESPUESTA VENCIDA</small><strong>{counters.companyOverdue}</strong><span>{counters.companyDueNext7Days} vencen en 7 días</span></button>
-      <button type="button" className={workflow === 'TO_SCHEDULE_VERIFICATION' ? 'active' : ''} onClick={() => setFilter('workflow', 'TO_SCHEDULE_VERIFICATION')}><small>PROGRAMAR VERIFICACIÓN</small><strong>{counters.awaitingVerificationSchedule}</strong><span>Respuesta ya recibida</span></button>
-      <button type="button" className={workflow === 'TO_VERIFY' || workflow === 'VERIFICATION_OVERDUE' ? 'active' : ''} onClick={() => setFilter('workflow', 'TO_VERIFY')}><small>PARA VERIFICAR</small><strong>{counters.toVerify}</strong><span>{counters.verificationOverdue} vencidos</span></button>
+      <button type="button" className={workflow === 'TO_SCHEDULE_VERIFICATION' ? 'active' : ''} onClick={() => setFilter('workflow', 'TO_SCHEDULE_VERIFICATION')}><small>SIN FECHA DE CONTROL</small><strong>{counters.withoutControlDate}</strong><span>Requieren definición operativa</span></button>
+      <button type="button" className={workflow === 'TO_VERIFY' ? 'active' : ''} onClick={() => setFilter('workflow', 'TO_VERIFY')}><small>CON CONTROL</small><strong>{counters.toVerify}</strong><span>{counters.verificationNext30Days} en próximos 30 días</span></button>
+      <button type="button" className={workflow === 'VERIFICATION_OVERDUE' ? 'active danger' : 'danger'} onClick={() => setFilter('workflow', 'VERIFICATION_OVERDUE')}><small>VERIFICACIÓN VENCIDA</small><strong>{counters.verificationOverdue}</strong><span>Requieren prioridad</span></button>
       <button type="button" className={workflow === 'READY_TO_CLOSE' ? 'active' : ''} onClick={() => setFilter('workflow', 'READY_TO_CLOSE')}><small>LISTOS PARA CERRAR</small><strong>{counters.readyToClose}</strong><span>Verificados conformes</span></button>
     </div>
 
     <form className="toolbar survey-toolbar" onSubmit={applySearch}>
-      <label className="search-field"><Icon name="search" /><input value={draftSearch} onChange={(event) => setDraftSearch(event.target.value)} placeholder="Buscar hallazgo, empresa, área, acta o elemento" /><button>Buscar</button></label>
+      <label className="search-field"><Icon name="search" /><input value={draftSearch} onChange={(event) => setDraftSearch(event.target.value)} placeholder="Buscar hallazgo, Descripción, empresa, área, acta o elemento" /><button>Buscar</button></label>
       <label className="select-field"><span>Vista</span><SearchableSelect value={workflow} onChange={(event) => setFilter('workflow', event.target.value)}>{workflows.map((item) => <option key={item.value} value={item.value}>{item.label}</option>)}</SearchableSelect></label>
       <OperationalFilters inspectorId={inspectorId} dateFrom={dateFrom} dateTo={dateTo} onChange={setFilter} />
     </form>
 
     {error && <Alert>{error}</Alert>}
-    {loading ? <LoadingBlock label="Cargando hallazgos…" /> : items.length === 0 ? <EmptyState title="Sin hallazgos en esta vista" text="No hay tareas pendientes para el filtro seleccionado." /> : <div className="table-panel findings-worklist">
+    {loading ? <LoadingBlock label="Cargando hallazgos…" /> : items.length === 0 ? <EmptyState title="Sin hallazgos en esta vista" text="No hay tareas técnicas pendientes para el filtro seleccionado." /> : <div className="table-panel findings-worklist">
       <div className="table-summary"><strong>{meta.total} hallazgo{meta.total === 1 ? '' : 's'}</strong><span>Página {page} de {Math.max(meta.totalPages, 1)}</span></div>
-      <div className="table-scroll"><table><thead><tr><th>Hallazgo</th><th>Empresa / área</th><th>Elemento</th><th>Situación</th><th>Próximo vencimiento</th><th>Documentación</th><th /></tr></thead><tbody>{items.map((finding) => {
+      <div className="table-scroll"><table><thead><tr><th>Hallazgo</th><th>Empresa / área</th><th>Elemento</th><th>Situación</th><th>Fecha de control</th><th>Descripción</th><th /></tr></thead><tbody>{items.map((finding) => {
         const attention = attentionLabel(finding);
         const deadline = deadlineText(finding);
         return <tr key={finding.id}>
@@ -180,7 +169,7 @@ export function FindingsPage() {
           <td><Link className="text-link" to={`/inventarios/${finding.assetId}`}>{finding.asset.name}<small className="block-muted">{finding.asset.code}</small></Link></td>
           <td><span className={`status-badge ${attention.className}`}>{attention.label}</span></td>
           <td><div className={`finding-deadline ${deadline.overdue ? 'overdue' : ''}`}><small>{deadline.title}</small><strong>{formatDateOnly(deadline.value)}</strong></div></td>
-          <td><small>{finding.companyResponseReceivedOn ? `Respuesta ${formatDateOnly(finding.companyResponseReceivedOn)}` : 'Sin respuesta'}</small></td>
+          <td><small>{finding.description}</small></td>
           <td className="action-cell"><Link className="icon-button" to={`/hallazgos/${finding.id}`} aria-label={`Abrir ${finding.code}`}><Icon name="chevron" /></Link></td>
         </tr>;
       })}</tbody></table></div>

From 212f4dcee507949d1217ea0a1286820eea70cf53 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:01:56 -0300
Subject: [PATCH 100/224] F4: remove obsolete finding company-response
 workspace

---
 .../inspections/FindingOfficeWorkspace.tsx    | 370 ------------------
 1 file changed, 370 deletions(-)
 delete mode 100644 web-v2/src/features/inspections/FindingOfficeWorkspace.tsx

diff --git a/web-v2/src/features/inspections/FindingOfficeWorkspace.tsx b/web-v2/src/features/inspections/FindingOfficeWorkspace.tsx
deleted file mode 100644
index 9ff3d37..0000000
--- a/web-v2/src/features/inspections/FindingOfficeWorkspace.tsx
+++ /dev/null
@@ -1,370 +0,0 @@
-import { SearchableSelect } from '../../components/SearchableSelect';
-import { useEffect, useRef, useState } from 'react';
-import type { FormEvent } from 'react';
-import { Link } from 'react-router';
-import { Alert, errorMessage } from '../../components/Feedback';
-import { Icon } from '../../components/Icon';
-import {
-  closeInspectionFinding,
-  createInspectionFindingCommunication,
-  updateInspectionFindingFollowUp,
-  uploadInspectionFindingEvidence,
-} from '../../lib/api';
-import type {
-  InspectionFinding,
-  InspectionFindingCommunication,
-  InspectionFindingOfficeWorkflow,
-} from '../../lib/api';
-import { formatDate, formatDateOnly } from '../../lib/format';
-
-function localDateTime(value: string | number | Date): string {
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return '';
-  const local = new Date(date.getTime() - date.getTimezoneOffset() * 60_000);
-  return local.toISOString().slice(0, 16);
-}
-
-function workflowFallback(finding: InspectionFinding): InspectionFindingOfficeWorkflow {
-  if (finding.status === 'CLOSED') {
-    return { stage: 'CLOSED', label: 'Hallazgo cerrado', action: 'El seguimiento está finalizado.', dueOn: null, overdue: false };
-  }
-  if (!finding.companyResponseReceivedOn) {
-    return { stage: 'WAITING_COMPANY', label: 'Esperando respuesta de empresa', action: 'Registrar la respuesta cuando sea recibida.', dueOn: finding.correctionDueOn, overdue: false };
-  }
-  if (finding.latestVerification?.outcome === 'RESOLVED' && finding.latestVerification.visitStatus === 'CLOSED') {
-    return { stage: 'READY_TO_CLOSE', label: 'Listo para cierre', action: 'Revisar la evidencia y cerrar administrativamente.', dueOn: null, overdue: false };
-  }
-  if (!finding.nextControlOn) {
-    return { stage: 'DEFINE_VERIFICATION', label: 'Definir fecha de verificación', action: 'Establecer cuándo debe volver a controlarse.', dueOn: null, overdue: false };
-  }
-  if (finding.verificationVisit) {
-    return { stage: 'VERIFICATION_PLANNED', label: 'Verificación planificada', action: 'Consultar la visita vinculada.', dueOn: finding.nextControlOn, overdue: false };
-  }
-  return { stage: 'PLAN_VERIFICATION', label: 'Verificación pendiente de planificación', action: 'Crear la visita de verificación.', dueOn: finding.nextControlOn, overdue: false };
-}
-
-function verificationEventLabel(eventType: NonNullable<InspectionFinding['verificationHistory']>[number]['eventType']): string {
-  if (eventType === 'CONTROL_DATE_DEFINED') return 'Fecha de verificación definida';
-  if (eventType === 'CONTROL_DATE_CHANGED') return 'Fecha de verificación reprogramada';
-  if (eventType === 'CONTROL_DATE_CLEARED') return 'Fecha de verificación consumida o retirada';
-  if (eventType === 'VISIT_PLANNED') return 'Visita de verificación planificada';
-  return 'Resultado de verificación registrado';
-}
-
-function verificationOutcomeLabel(outcome: NonNullable<InspectionFinding['latestVerification']>['outcome']): string {
-  if (outcome === 'RESOLVED') return 'Solucionado';
-  if (outcome === 'NOT_RESOLVED') return 'No solucionado';
-  if (outcome === 'REQUIRES_NEW_DATE') return 'Requiere nueva fecha';
-  return '';
-}
-
-
-export function FindingOfficeWorkspace({
-  finding,
-  canFollowUp,
-  canClose,
-  canCreateEvidence,
-  canCreateCommunications,
-  onFindingChanged,
-  onEvidenceChanged,
-}: {
-  finding: InspectionFinding;
-  canFollowUp: boolean;
-  canClose: boolean;
-  canCreateEvidence: boolean;
-  canCreateCommunications: boolean;
-  onFindingChanged: (finding: InspectionFinding) => void;
-  onEvidenceChanged: () => void;
-}) {
-  const responseFileRef = useRef<HTMLInputElement | null>(null);
-  const [busy, setBusy] = useState(false);
-  const [error, setError] = useState('');
-  const [success, setSuccess] = useState('');
-  const [responseText, setResponseText] = useState('');
-  const [responseOccurredAt, setResponseOccurredAt] = useState(localDateTime(new Date()));
-  const [responseChannel, setResponseChannel] = useState<InspectionFindingCommunication['channel']>('EMAIL');
-  const [responseContactName, setResponseContactName] = useState('');
-  const [responseContactEmail, setResponseContactEmail] = useState('');
-  const [responseFile, setResponseFile] = useState<File | null>(null);
-  const [responseDueBasis, setResponseDueBasis] = useState<'FINDING_DATE' | 'REPORT_NOTIFICATION' | ''>(finding.responseDueBasis ?? '');
-  const [responseDueDays, setResponseDueDays] = useState(finding.responseDueDays == null ? '' : String(finding.responseDueDays));
-  const [reportNotifiedOn, setReportNotifiedOn] = useState(finding.reportNotifiedOn ?? '');
-  const [committedOn, setCommittedOn] = useState(finding.companyCommittedCorrectionOn ?? '');
-  const [nextControlOn, setNextControlOn] = useState(finding.nextControlOn ?? '');
-  const [closureNotes, setClosureNotes] = useState('');
-
-  useEffect(() => {
-    setResponseText('');
-    setResponseDueBasis(finding.responseDueBasis ?? '');
-    setResponseDueDays(finding.responseDueDays == null ? '' : String(finding.responseDueDays));
-    setReportNotifiedOn(finding.reportNotifiedOn ?? '');
-    setCommittedOn(finding.companyCommittedCorrectionOn ?? '');
-    setNextControlOn(finding.nextControlOn ?? '');
-  }, [finding.id, finding.responseDueBasis, finding.responseDueDays, finding.reportNotifiedOn, finding.companyCommittedCorrectionOn, finding.nextControlOn]);
-
-  const workflow = finding.officeWorkflow ?? workflowFallback(finding);
-  const hasResponse = Boolean(finding.companyResponseReceivedOn);
-  const verificationDone = Boolean(finding.latestVerification?.outcome);
-  const closed = finding.status === 'CLOSED';
-  const verificationReadyToClose = finding.latestVerification?.outcome === 'RESOLVED'
-    && finding.latestVerification.visitStatus === 'CLOSED';
-  const verificationActive = Boolean(finding.verificationVisit);
-  const verificationHistory = finding.verificationHistory ?? [];
-
-  const saveResponseDeadline = async (event: FormEvent) => {
-    event.preventDefault();
-    if (!responseDueBasis || responseDueDays === '') return;
-    if (responseDueBasis === 'REPORT_NOTIFICATION' && !reportNotifiedOn) return;
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      const updated = await updateInspectionFindingFollowUp(finding.id, {
-        responseDueBasis,
-        responseDueDays: Number(responseDueDays),
-        reportNotifiedOn: responseDueBasis === 'REPORT_NOTIFICATION' ? reportNotifiedOn : null,
-      });
-      onFindingChanged(updated);
-      setSuccess('Plazo administrativo calculado y guardado con su fecha base.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const registerResponse = async (event: FormEvent) => {
-    event.preventDefault();
-    if (!responseText.trim() || !responseOccurredAt) return;
-    const receivedOn = responseOccurredAt.slice(0, 10);
-    const firstPresentation = !hasResponse;
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      let updated = finding;
-      if (firstPresentation) {
-        updated = await updateInspectionFindingFollowUp(finding.id, {
-          companyResponse: responseText.trim(),
-          companyResponseReceivedOn: receivedOn,
-          companyCommittedCorrectionOn: committedOn || null,
-          nextControlOn: nextControlOn || null,
-        });
-        onFindingChanged(updated);
-      } else if (
-        committedOn !== (finding.companyCommittedCorrectionOn ?? '')
-        || nextControlOn !== (finding.nextControlOn ?? '')
-      ) {
-        updated = await updateInspectionFindingFollowUp(finding.id, {
-          companyCommittedCorrectionOn: committedOn || null,
-          nextControlOn: nextControlOn || null,
-        });
-        onFindingChanged(updated);
-      }
-
-      let communicationId = '';
-      let traceWarning = '';
-      if (canCreateCommunications) {
-        try {
-          const communication = await createInspectionFindingCommunication(finding.id, {
-            type: 'COMPANY_RESPONSE',
-            direction: 'INBOUND',
-            channel: responseChannel,
-            occurredAt: new Date(responseOccurredAt).toISOString(),
-            subject: `${firstPresentation ? 'Respuesta' : 'Nueva presentación'} de empresa · ${finding.code}`,
-            details: responseText.trim(),
-            contactName: responseContactName.trim() || null,
-            contactEmail: responseContactEmail.trim() || null,
-          });
-          communicationId = communication.id;
-          onEvidenceChanged();
-        } catch (requestError) {
-          traceWarning = `${firstPresentation ? 'La primera respuesta' : 'La actualización de seguimiento'} quedó registrada, pero la presentación histórica no pudo incorporarse: ${errorMessage(requestError)}`;
-        }
-      } else {
-        traceWarning = 'No tenés permiso para incorporar la presentación a la trazabilidad histórica.';
-      }
-
-      if (responseFile && canCreateEvidence) {
-        if (!communicationId) {
-          traceWarning = traceWarning || 'El documento debe incorporarse desde Documentos y trazabilidad porque no existe una presentación histórica vinculada.';
-        } else {
-          try {
-            await uploadInspectionFindingEvidence(finding.id, {
-              file: responseFile,
-              kind: 'DOCUMENT',
-              purpose: 'COMPANY_RESPONSE',
-              communicationId,
-              title: responseFile.name,
-              description: `Documento presentado por la empresa para ${finding.code}`,
-              capturedAt: new Date(responseOccurredAt).toISOString(),
-              deviceLabel: navigator.userAgent.slice(0, 200),
-            });
-            onEvidenceChanged();
-          } catch (requestError) {
-            traceWarning = `La presentación quedó registrada, pero el documento no pudo incorporarse: ${errorMessage(requestError)}`;
-          }
-        }
-      }
-
-      setResponseText('');
-      setResponseContactName('');
-      setResponseContactEmail('');
-      setResponseOccurredAt(localDateTime(new Date()));
-      setResponseFile(null);
-      if (responseFileRef.current) responseFileRef.current.value = '';
-      setSuccess(firstPresentation
-        ? 'Primera respuesta registrada. Las presentaciones posteriores se agregarán sin modificar esta respuesta original.'
-        : 'Nueva presentación agregada al historial del hallazgo. La respuesta original permanece inmutable.');
-      if (traceWarning) setError(traceWarning);
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const saveOperationalFollowUp = async (event: FormEvent) => {
-    event.preventDefault();
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      const updated = await updateInspectionFindingFollowUp(finding.id, {
-        companyCommittedCorrectionOn: committedOn || null,
-        nextControlOn: nextControlOn || null,
-      });
-      onFindingChanged(updated);
-      setSuccess('Seguimiento operativo actualizado. El cambio de fecha quedó agregado al historial sin borrar los controles anteriores.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const closeFinding = async (event: FormEvent) => {
-    event.preventDefault();
-    if (!closureNotes.trim()) return;
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      const updated = await closeInspectionFinding(finding.id, closureNotes.trim());
-      onFindingChanged(updated);
-      setClosureNotes('');
-      setSuccess('Hallazgo cerrado. La conclusión quedó incorporada al expediente histórico.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  return <article className="panel finding-office-workspace">
-    <div className="panel-heading">
-      <div><span className="eyebrow">EXPEDIENTE OPERATIVO</span><h2>Dar curso al hallazgo</h2><p className="section-copy">Respuesta, documentación, vencimientos, verificación y cierre desde una sola ficha.</p></div>
-      <span className={`status-badge large ${workflow.overdue ? 'observed' : workflow.stage === 'CLOSED' ? 'active' : 'pending'}`}>{workflow.label}</span>
-    </div>
-
-    {error && <Alert>{error}</Alert>}
-    {success && <Alert type="success">{success}</Alert>}
-
-    <div className="finding-case-progress" aria-label="Etapas del seguimiento">
-      <div className="done"><span>1</span><strong>Hallazgo</strong><small>Registrado</small></div>
-      <i>›</i>
-      <div className={hasResponse ? 'done' : 'current'}><span>2</span><strong>Empresa</strong><small>{hasResponse ? 'Respuesta recibida' : 'Esperando respuesta'}</small></div>
-      <i>›</i>
-      <div className={verificationDone ? 'done' : hasResponse ? 'current' : 'pending'}><span>3</span><strong>Verificación</strong><small>{verificationDone ? 'Resultado registrado' : finding.verificationVisit ? 'Visita planificada' : finding.nextControlOn ? 'Fecha definida' : 'Pendiente'}</small></div>
-      <i>›</i>
-      <div className={closed ? 'done' : verificationReadyToClose ? 'current' : 'pending'}><span>4</span><strong>Cierre</strong><small>{closed ? 'Finalizado' : verificationReadyToClose ? 'Listo para cerrar' : 'Pendiente'}</small></div>
-    </div>
-
-    {!closed && <div className={`finding-recommended-action ${workflow.overdue ? 'overdue' : ''}`}>
-      <div><span className="eyebrow">ACCIÓN RECOMENDADA</span><strong>{workflow.label}</strong><p>{workflow.action}{workflow.dueOn ? ` Fecha: ${formatDateOnly(workflow.dueOn)}.` : ''}</p></div>
-      <div className="form-actions">
-        {(workflow.stage === 'WAITING_COMPANY' || workflow.stage === 'COMPANY_OVERDUE') && <a className="button primary" href="#respuesta-empresa">Registrar respuesta</a>}
-        {(workflow.stage === 'DEFINE_VERIFICATION' || workflow.stage === 'RESCHEDULE_VERIFICATION') && <a className="button primary" href="#seguimiento-operativo">Definir fecha</a>}
-        {workflow.stage === 'PLAN_VERIFICATION' && <Link className="button primary" to="/hallazgos/planificacion">Planificar visita <Icon name="chevron" /></Link>}
-        {workflow.stage === 'VERIFICATION_PLANNED' && finding.verificationVisit && <Link className="button primary" to={`/inspecciones/${finding.verificationVisit.id}`}>Abrir verificación <Icon name="chevron" /></Link>}
-        {workflow.stage === 'READY_TO_CLOSE' && <a className="button primary" href="#cierre-hallazgo">Revisar y cerrar</a>}
-      </div>
-    </div>}
-
-    <div className="finding-office-sections">
-      <section id="respuesta-empresa" className={`finding-office-step ${hasResponse ? 'complete' : ''}`}>
-        <div className="subsection-heading"><div><span className="eyebrow">1 · ADMINISTRATIVO</span><h3>Respuesta de la empresa</h3></div><span className={`status-badge ${hasResponse ? 'active' : workflow.stage === 'COMPANY_OVERDUE' ? 'observed' : 'pending'}`}>{hasResponse ? 'Recibida' : workflow.stage === 'COMPANY_OVERDUE' ? 'Vencida' : 'Pendiente'}</span></div>
-        {!hasResponse && canFollowUp && <form className="finding-office-form finding-deadline-form" onSubmit={saveResponseDeadline}>
-          <div className="form-grid">
-            <label className="field"><span>Inicio del plazo de respuesta</span><SearchableSelect value={responseDueBasis} onChange={(event) => setResponseDueBasis(event.target.value as 'FINDING_DATE' | 'REPORT_NOTIFICATION' | '')}><option value="">Seleccionar…</option><option value="FINDING_DATE">Desde el día del hallazgo</option><option value="REPORT_NOTIFICATION">Desde la notificación del informe</option></SearchableSelect></label>
-            <label className="field"><span>Cantidad de días</span><input type="number" min="0" max="3650" value={responseDueDays} onChange={(event) => setResponseDueDays(event.target.value)} placeholder="Ej.: 5" /></label>
-            {responseDueBasis === 'REPORT_NOTIFICATION' && <label className="field"><span>Informe notificado el</span><input type="date" value={reportNotifiedOn} onChange={(event) => setReportNotifiedOn(event.target.value)} /></label>}
-          </div>
-          <p className="field-help">DH guarda la regla, la fecha base y el vencimiento calculado. Para casos críticos puede computarse desde el hallazgo; para los demás, desde la notificación del informe.</p>
-          <div className="form-actions"><button className="button secondary" disabled={busy || !responseDueBasis || responseDueDays === '' || (responseDueBasis === 'REPORT_NOTIFICATION' && !reportNotifiedOn)}><Icon name="calendar" />Calcular vencimiento</button></div>
-        </form>}
-        <div className="finding-office-deadline-row"><div><small>Vencimiento empresa</small><strong>{formatDateOnly(finding.correctionDueOn)}</strong>{finding.responseDueBasis && <span>{finding.responseDueBasis === 'FINDING_DATE' ? 'Desde hallazgo' : 'Desde notificación'} · {finding.responseDueDays ?? 0} día{finding.responseDueDays === 1 ? '' : 's'} · base {formatDateOnly(finding.responseDueBaseOn)}</span>}</div>{hasResponse && <div><small>Respuesta recibida</small><strong>{formatDateOnly(finding.companyResponseReceivedOn)}</strong></div>}</div>
-
-        {!closed && canFollowUp && <form className="finding-office-form" onSubmit={registerResponse}>
-          <label className="field"><span>{hasResponse ? 'Nueva presentación / ampliación de la empresa' : 'Respuesta o descargo recibido'}</span><textarea required rows={5} maxLength={20000} value={responseText} onChange={(event) => setResponseText(event.target.value)} placeholder={hasResponse ? 'Registrar sólo la nueva presentación; la respuesta original no se modifica…' : 'Resumir la presentación, acción correctiva o descargo recibido…'} /></label>
-          <div className="form-grid finding-response-grid">
-            <label className="field"><span>Recibida el</span><input type="datetime-local" required value={responseOccurredAt} onChange={(event) => setResponseOccurredAt(event.target.value)} /></label>
-            <label className="field"><span>Medio</span><SearchableSelect value={responseChannel} onChange={(event) => setResponseChannel(event.target.value as InspectionFindingCommunication['channel'])}><option value="EMAIL">Email</option><option value="LETTER">Nota formal</option><option value="IN_PERSON">Presencial</option><option value="PHONE">Teléfono</option><option value="SYSTEM">Sistema</option><option value="OTHER">Otro medio</option></SearchableSelect></label>
-            <label className="field"><span>Fecha informada por la empresa <em>opcional</em></span><input type="date" value={committedOn} onChange={(event) => setCommittedOn(event.target.value)} /></label>
-            <label className="field"><span>Fecha de verificación <em>opcional</em></span><input type="date" value={nextControlOn} onChange={(event) => setNextControlOn(event.target.value)} /></label>
-          </div>
-          {canCreateCommunications && <div className="form-grid"><label className="field"><span>Contacto <em>opcional</em></span><input maxLength={200} value={responseContactName} onChange={(event) => setResponseContactName(event.target.value)} /></label><label className="field"><span>Email de contacto <em>opcional</em></span><input type="email" maxLength={320} value={responseContactEmail} onChange={(event) => setResponseContactEmail(event.target.value)} /></label></div>}
-          {canCreateCommunications && canCreateEvidence && <label className="field"><span>Documento presentado por la empresa <em>opcional</em></span><input ref={responseFileRef} type="file" accept="application/pdf" onChange={(event) => setResponseFile(event.target.files?.[0] ?? null)} /><small className="field-help">Si adjuntás un PDF, queda vinculado a la respuesta recibida y protegido con SHA-256.</small></label>}
-          <p className="field-help">Registrar la respuesta cumple el vencimiento administrativo. La fecha informada por la empresa es sólo un compromiso declarado y la fecha de verificación sigue siendo una decisión operativa de DH.</p>
-          <div className="form-actions"><button className="button primary" disabled={busy || !responseText.trim() || !responseOccurredAt}><Icon name="check" />{busy ? 'Registrando…' : hasResponse ? 'Agregar presentación' : 'Registrar respuesta'}</button></div>
-        </form>}
-
-        {hasResponse && <div className="finding-response-record">
-          <div><small>Primera respuesta registrada · inmutable</small><p>{finding.companyResponse}</p></div>
-          <div><small>Fecha informada por la empresa</small><strong>{formatDateOnly(finding.companyCommittedCorrectionOn)}</strong></div>
-        </div>}
-      </section>
-
-      <section id="seguimiento-operativo" className={`finding-office-step ${finding.nextControlOn || verificationDone ? 'complete' : ''}`}>
-        <div className="subsection-heading"><div><span className="eyebrow">2 · OPERATIVO</span><h3>Verificación del hallazgo</h3></div><span className={`status-badge ${verificationDone ? 'active' : finding.nextControlOn ? 'pending' : 'draft'}`}>{verificationDone ? 'Verificado' : finding.nextControlOn ? 'Fecha definida' : 'Sin fecha'}</span></div>
-        {hasResponse && canFollowUp && !closed && <form className="finding-office-form" onSubmit={saveOperationalFollowUp}>
-          <div className="form-grid finding-follow-up-dates">
-            <label className="field"><span>Fecha informada por la empresa</span><input type="date" value={committedOn} onChange={(event) => setCommittedOn(event.target.value)} /></label>
-            <label className="field"><span>Fecha de verificación / resolución</span><input type="date" value={nextControlOn} onChange={(event) => setNextControlOn(event.target.value)} /></label>
-          </div>
-          <p className="field-help">El vencimiento administrativo original permanece intacto. Esta segunda fecha alimenta la planificación de verificaciones e inspecciones.</p>
-          <div className="form-actions"><button className="button secondary" disabled={busy}><Icon name="check" />Guardar seguimiento</button>{nextControlOn && !finding.verificationVisit && finding.latestVerification?.outcome !== 'RESOLVED' && <Link className="button primary" to="/hallazgos/planificacion">Planificar verificación <Icon name="chevron" /></Link>}{finding.verificationVisit && <Link className="button secondary" to={`/inspecciones/${finding.verificationVisit.id}`}>Abrir visita <Icon name="chevron" /></Link>}</div>
-        </form>}
-        {!hasResponse && <div className="inline-empty">La planificación operativa se habilita cuando se registra la respuesta de la empresa.</div>}
-        {finding.latestVerification?.outcome && <div className="finding-verification-record"><small>Último resultado de campo</small><strong>{verificationOutcomeLabel(finding.latestVerification.outcome)}</strong><span>{formatDate(finding.latestVerification.verifiedAt)} · {finding.latestVerification.visitCode}</span><p>{finding.latestVerification.resultNotes || 'Sin observaciones adicionales.'}</p></div>}
-        {verificationHistory.length > 0 && <div className="finding-verification-history">
-          <div className="finding-verification-history-heading"><div><small>TRAZABILIDAD APPEND-ONLY</small><strong>Historial completo de verificaciones</strong></div><span>{verificationHistory.length} evento{verificationHistory.length === 1 ? '' : 's'}</span></div>
-          <div className="finding-verification-timeline">{verificationHistory.map((event) => <div className="finding-verification-event" key={event.id}>
-            <div className="finding-verification-event-dot" />
-            <div className="finding-verification-event-body">
-              <div className="finding-verification-event-title"><strong>{verificationEventLabel(event.eventType)}</strong><span>{formatDate(event.occurredAt)}</span></div>
-              {event.outcome && <span className="status-badge pending">{verificationOutcomeLabel(event.outcome)}</span>}
-              {event.eventType.startsWith('CONTROL_DATE_') && (event.previousControlOn || event.nextControlOn) && <div className="finding-verification-date-change"><small>Fecha anterior</small><strong>{formatDateOnly(event.previousControlOn)}</strong><i>→</i><small>Nueva fecha</small><strong>{formatDateOnly(event.nextControlOn)}</strong></div>}
-              {(event.eventType === 'VISIT_PLANNED' || event.eventType === 'RESULT_RECORDED') && event.targetControlOn && <div className="finding-verification-target-date"><small>{event.eventType === 'VISIT_PLANNED' ? 'Control previsto' : 'Fecha que se verificó'}</small><strong>{formatDateOnly(event.targetControlOn)}</strong></div>}
-              {event.verificationVisit && <Link className="finding-verification-visit-link" to={`/inspecciones/${event.verificationVisit.id}`}><span>{event.verificationVisit.code}</span><Icon name="chevron" /></Link>}
-              {event.notes && <p>{event.notes}</p>}
-              <div className="finding-verification-event-meta"><span>{event.actorUsername || 'Sistema'}</span>{event.evidenceCount > 0 && <span>{event.evidenceCount} evidencia{event.evidenceCount === 1 ? '' : 's'}</span>}</div>
-            </div>
-          </div>)}</div>
-        </div>}
-      </section>
-
-      <section id="cierre-hallazgo" className={`finding-office-step ${closed ? 'complete' : ''}`}>
-        <div className="subsection-heading"><div><span className="eyebrow">3 · CIERRE</span><h3>{closed ? 'Hallazgo cerrado' : verificationReadyToClose ? 'Listo para cierre' : 'Decisión administrativa'}</h3></div><span className={`status-badge ${closed ? 'active' : verificationReadyToClose ? 'active' : 'draft'}`}>{closed ? 'Cerrado' : verificationReadyToClose ? 'Revisar' : 'Pendiente'}</span></div>
-        {closed ? <div className="finding-response-record"><div><small>Cerrado el</small><strong>{formatDate(finding.closedAt)}</strong><p>{finding.closureNotes}</p></div></div> : canClose ? <form className="finding-office-form" onSubmit={closeFinding}>
-          {verificationReadyToClose && <Alert type="success">La verificación de campo indicó que el hallazgo está solucionado. Revisá fotos y documentos antes de registrar el cierre.</Alert>}
-          <label className="field"><span>Conclusión de cierre</span><textarea rows={4} maxLength={5000} value={closureNotes} onChange={(event) => setClosureNotes(event.target.value)} placeholder="Indicar qué se revisó, qué respaldo existe y por qué corresponde cerrar el hallazgo…" /></label>
-          <p className="field-help">{verificationActive ? 'Existe una visita de verificación activa. Debe finalizar antes del cierre administrativo.' : 'El cierre queda versionado y auditado. Los documentos y fotos continúan disponibles en el expediente.'}</p>
-          <div className="form-actions"><a className="button text" href="#documentos-hallazgo">Revisar documentos</a><button className="button danger-outline" disabled={busy || verificationActive || closureNotes.trim().length < 3}><Icon name="check" />Cerrar hallazgo</button></div>
-        </form> : <div className="inline-empty">El cierre está reservado a Inspector, Supervisor o Director.</div>}
-      </section>
-    </div>
-
-    {hasResponse && <div className="finding-office-footnote"><Icon name="history" /><span>Respuesta recibida {formatDateOnly(finding.companyResponseReceivedOn)} · Las presentaciones sucesivas, medios y documentos quedan en la trazabilidad sin modificar la respuesta original. {finding.companyCommittedCorrectionOn ? `La empresa informó ${formatDateOnly(finding.companyCommittedCorrectionOn)}.` : 'La empresa no informó una fecha de corrección.'}</span></div>}
-  </article>;
-}

From ce33b328200d0000a9a48d7de4928a254933038e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:06:12 -0300
Subject: [PATCH 101/224] F4: isolate technical inspection checklist and public
 visit model

---
 .../f4-inspection-visits.service.ts           | 152 ++++++++++++++++++
 1 file changed, 152 insertions(+)
 create mode 100644 api-v3/src/inspection-visits/f4-inspection-visits.service.ts

diff --git a/api-v3/src/inspection-visits/f4-inspection-visits.service.ts b/api-v3/src/inspection-visits/f4-inspection-visits.service.ts
new file mode 100644
index 0000000..373f4f7
--- /dev/null
+++ b/api-v3/src/inspection-visits/f4-inspection-visits.service.ts
@@ -0,0 +1,152 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { AuditService } from '../audit/audit.service';
+import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
+import type { CreateInspectionVisitDto } from './dto/create-inspection-visit.dto';
+import type { ListInspectionVisitsQueryDto } from './dto/list-inspection-visits-query.dto';
+import type { InspectionVisitView } from './inspection-visits.service';
+import { InspectionVisitsService } from './inspection-visits.service';
+
+/**
+ * Capa activa F4 sobre el servicio histórico de Inspecciones.
+ *
+ * Mantiene las operaciones de planificación/equipo/Inventario ya probadas, pero
+ * elimina de la salida funcional los conceptos retirados en F4:
+ * - no existe un título de negocio independiente del código institucional;
+ * - no existe fecha prevista de fin;
+ * - el checklist es exclusivamente técnico y nunca depende de respuestas de empresa.
+ *
+ * Las columnas legacy permanecen temporalmente en PostgreSQL para una migración de
+ * limpieza posterior a la validación del piloto, sin intervenir datos históricos a ciegas.
+ */
+@Injectable()
+export class F4InspectionVisitsService extends InspectionVisitsService {
+  constructor(
+    private readonly f4DataSource: DataSource,
+    audit: AuditService,
+  ) {
+    super(f4DataSource, audit);
+  }
+
+  override async list(query: ListInspectionVisitsQueryDto) {
+    const response = await super.list(query);
+    return {
+      ...response,
+      data: response.data.map((visit) => this.normalizeVisit(visit)),
+    };
+  }
+
+  override async getById(id: string): Promise<InspectionVisitView> {
+    await this.reclassifyCurrentChecklist(id);
+    return this.normalizeVisit(await super.getById(id));
+  }
+
+  override async create(
+    dto: CreateInspectionVisitDto,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ): Promise<InspectionVisitView> {
+    const created = await super.create(dto, principal, request);
+    await this.reclassifyCurrentChecklist(created.id);
+    return this.normalizeVisit(await super.getById(created.id));
+  }
+
+  override async generateChecklist(
+    id: string,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ): Promise<InspectionVisitView> {
+    await super.generateChecklist(id, principal, request);
+    await this.reclassifyCurrentChecklist(id);
+    return this.normalizeVisit(await super.getById(id));
+  }
+
+  private normalizeVisit<T extends { code: string; title: string; plannedEndAt: Date | null }>(visit: T): T {
+    const normalized = {
+      ...visit,
+      // Compatibilidad de contrato: consumidores antiguos reciben el identificador,
+      // no un segundo nombre persistente que pueda divergir.
+      title: visit.code,
+      plannedEndAt: null,
+    } as T;
+
+    if ('checklist' in normalized) {
+      const view = normalized as T & InspectionVisitView;
+      view.checklist = {
+        ...view.checklist,
+        companyOverdue: 0,
+        items: view.checklist.items.filter((item) => item.itemKind !== 'COMPANY_OVERDUE'),
+      };
+    }
+    return normalized;
+  }
+
+  private async reclassifyCurrentChecklist(visitId: string): Promise<void> {
+    await this.f4DataSource.transaction(async (manager) => {
+      const [visit] = await manager.query(`
+        SELECT checklist_generation AS generation, planned_start_at AS "plannedStartAt"
+        FROM inspection_visits
+        WHERE id=$1
+        FOR UPDATE
+      `, [visitId]) as Array<{ generation: number; plannedStartAt: Date | null }>;
+      if (!visit || Number(visit.generation) < 1 || !visit.plannedStartAt) return;
+
+      const targetDate = new Date(visit.plannedStartAt).toISOString().slice(0, 10);
+      await manager.query(`
+        UPDATE inspection_visit_checklist_items item
+        SET
+          item_kind = CASE
+            WHEN finding.status='OPEN'
+              AND finding.next_control_on IS NOT NULL
+              AND finding.next_control_on < $3::date
+              AND COALESCE((
+                SELECT verification.outcome
+                FROM inspection_finding_verification_visits verification
+                WHERE verification.finding_id=finding.id
+                  AND verification.outcome IS NOT NULL
+                ORDER BY verification.result_recorded_at DESC NULLS LAST,
+                         verification.created_at DESC,
+                         verification.id DESC
+                LIMIT 1
+              ), '') <> 'RESOLVED'
+              THEN 'VERIFICATION_OVERDUE'
+            WHEN finding.status='OPEN'
+              AND finding.next_control_on IS NOT NULL
+              AND finding.next_control_on BETWEEN $3::date AND ($3::date + 30)
+              AND COALESCE((
+                SELECT verification.outcome
+                FROM inspection_finding_verification_visits verification
+                WHERE verification.finding_id=finding.id
+                  AND verification.outcome IS NOT NULL
+                ORDER BY verification.result_recorded_at DESC NULLS LAST,
+                         verification.created_at DESC,
+                         verification.id DESC
+                LIMIT 1
+              ), '') <> 'RESOLVED'
+              THEN 'UPCOMING_CONTROL'
+            ELSE 'ANTECEDENT'
+          END,
+          reference_on = CASE
+            WHEN finding.status='OPEN'
+              AND finding.next_control_on IS NOT NULL
+              AND COALESCE((
+                SELECT verification.outcome
+                FROM inspection_finding_verification_visits verification
+                WHERE verification.finding_id=finding.id
+                  AND verification.outcome IS NOT NULL
+                ORDER BY verification.result_recorded_at DESC NULLS LAST,
+                         verification.created_at DESC,
+                         verification.id DESC
+                LIMIT 1
+              ), '') <> 'RESOLVED'
+              THEN finding.next_control_on
+            ELSE NULL
+          END
+        FROM inspection_findings finding
+        WHERE item.visit_id=$1
+          AND item.generation_number=$2
+          AND finding.id=item.finding_id
+      `, [visitId, visit.generation, targetDate]);
+    });
+  }
+}

From 69bc7208991e1c7974256d70a333d947e459446c Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:06:21 -0300
Subject: [PATCH 102/224] F4: activate inspection visit compatibility layer

---
 api-v3/src/inspection-visits/inspection-visits.module.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/api-v3/src/inspection-visits/inspection-visits.module.ts b/api-v3/src/inspection-visits/inspection-visits.module.ts
index 0c48c7f..1f139e7 100644
--- a/api-v3/src/inspection-visits/inspection-visits.module.ts
+++ b/api-v3/src/inspection-visits/inspection-visits.module.ts
@@ -3,6 +3,7 @@ import { AssetMasterModule } from '../asset-master/asset-master.module';
 import { AuditModule } from '../audit/audit.module';
 import { InspectionFindingsModule } from '../inspection-findings/inspection-findings.module';
 import { F3FieldInventoryStructureService } from './f3-field-inventory-structure.service';
+import { F4InspectionVisitsService } from './f4-inspection-visits.service';
 import { FieldFindingsController } from './field-findings.controller';
 import { FieldFindingsService } from './field-findings.service';
 import { FieldInventoryController } from './field-inventory.controller';
@@ -15,7 +16,7 @@ import { InspectionVisitsService } from './inspection-visits.service';
   imports: [AuditModule, AssetMasterModule, InspectionFindingsModule],
   controllers: [InspectionVisitsController, FieldInventoryController, FieldFindingsController],
   providers: [
-    InspectionVisitsService,
+    { provide: InspectionVisitsService, useClass: F4InspectionVisitsService },
     InspectionVisitLifecycleService,
     FieldInventoryService,
     F3FieldInventoryStructureService,

From 0a6500fbffe9de14e4e75a052ae8e0e00d7c7167 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:08:34 -0300
Subject: [PATCH 103/224] F4: add explicit inspection unplan lifecycle action

---
 .../inspection-visit-lifecycle.service.ts     | 45 ++++++++++++++++++-
 1 file changed, 43 insertions(+), 2 deletions(-)

diff --git a/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
index e420083..013bfbe 100644
--- a/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
+++ b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
@@ -43,7 +43,6 @@ export class InspectionVisitLifecycleService {
         });
       }
       await this.validatePlanningContext(manager, visit);
-      const before = visit.status;
       visit.status = InspectionVisitStatus.PLANNED;
       visit.cancellationReason = null;
       visit.updatedBy = principal.userId;
@@ -53,7 +52,7 @@ export class InspectionVisitLifecycleService {
         action: AuditAction.INSPECTION_VISIT_STATUS_CHANGED,
         entityType: 'inspection_visit',
         entityId: id,
-        beforeData: { status: before },
+        beforeData: { status: InspectionVisitStatus.DRAFT },
         afterData: { status: InspectionVisitStatus.PLANNED },
         metadata: { transition: 'PLAN' },
       }, manager);
@@ -61,6 +60,48 @@ export class InspectionVisitLifecycleService {
     return this.visits.getById(id);
   }
 
+  async unplan(
+    id: string,
+    principal: AuthPrincipal,
+    request: RequestWithContext,
+  ) {
+    await this.dataSource.transaction(async (manager) => {
+      const visit = await this.lockVisit(manager, id);
+      if (visit.status !== InspectionVisitStatus.PLANNED) {
+        throw new ConflictException({
+          code: 'INSPECTION_NOT_PLANNED_FOR_UNPLAN',
+          message: 'Sólo una Inspección planificada puede volver a borrador',
+        });
+      }
+      const [startedAct] = await manager.query(`
+        SELECT 1
+        FROM inspection_acts act
+        WHERE act.visit_id=$1
+          AND act.status NOT IN ('DRAFT','CANCELLED')
+        LIMIT 1
+      `, [id]) as unknown[];
+      if (startedAct) {
+        throw new ConflictException({
+          code: 'INSPECTION_UNPLAN_ACT_ALREADY_ADVANCED',
+          message: 'La Inspección ya tiene un Acta avanzada y no puede volver a borrador',
+        });
+      }
+      visit.status = InspectionVisitStatus.DRAFT;
+      visit.updatedBy = principal.userId;
+      await manager.getRepository(InspectionVisit).save(visit);
+      await this.audit.record({
+        ...administrationAuditContext(principal, request),
+        action: AuditAction.INSPECTION_VISIT_STATUS_CHANGED,
+        entityType: 'inspection_visit',
+        entityId: id,
+        beforeData: { status: InspectionVisitStatus.PLANNED },
+        afterData: { status: InspectionVisitStatus.DRAFT },
+        metadata: { transition: 'UNPLAN', explicitAction: true },
+      }, manager);
+    });
+    return this.visits.getById(id);
+  }
+
   async start(
     id: string,
     principal: AuthPrincipal,

From 91480779ddd425bea5fcb225a79432973c133fef Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:08:55 -0300
Subject: [PATCH 104/224] F4: expose explicit inspection unplan action

---
 .../inspection-visits/inspection-visits.controller.ts  | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/api-v3/src/inspection-visits/inspection-visits.controller.ts b/api-v3/src/inspection-visits/inspection-visits.controller.ts
index 4ded255..7be5b20 100644
--- a/api-v3/src/inspection-visits/inspection-visits.controller.ts
+++ b/api-v3/src/inspection-visits/inspection-visits.controller.ts
@@ -149,6 +149,16 @@ export class InspectionVisitsController {
     return this.lifecycle.plan(id, principal, request);
   }
 
+  @Post(':id/unplan')
+  @RequirePermissions('inspections.manage')
+  unplan(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @CurrentAuth() principal: AuthPrincipal,
+    @Req() request: RequestWithContext,
+  ) {
+    return this.lifecycle.unplan(id, principal, request);
+  }
+
   @Post(':id/start')
   @RequirePermissions('inspections.execute')
   start(

From 572c8a4af1f8816d07d6de8eeef06e8fb2a8730d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:09:05 -0300
Subject: [PATCH 105/224] F4: add explicit inspection lifecycle client

---
 web-v2/src/lib/inspectionVisitLifecycleApi.ts | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 web-v2/src/lib/inspectionVisitLifecycleApi.ts

diff --git a/web-v2/src/lib/inspectionVisitLifecycleApi.ts b/web-v2/src/lib/inspectionVisitLifecycleApi.ts
new file mode 100644
index 0000000..4c28769
--- /dev/null
+++ b/web-v2/src/lib/inspectionVisitLifecycleApi.ts
@@ -0,0 +1,17 @@
+import { apiRequest } from './api';
+import type { InspectionVisit } from './api';
+
+export function planInspectionVisit(id: string) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/plan`, { method: 'POST' });
+}
+
+export function unplanInspectionVisit(id: string) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/unplan`, { method: 'POST' });
+}
+
+export function cancelInspectionVisit(id: string, reason: string) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/cancel`, {
+    method: 'POST',
+    body: JSON.stringify({ reason }),
+  });
+}

From 3180101ef7bb5bbfa61bed3541137e4737fb77d4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:10:01 -0300
Subject: [PATCH 106/224] F4: add clean inspection planning editor

---
 .../src/pages/InspectionVisitEditorF4Page.tsx | 361 ++++++++++++++++++
 1 file changed, 361 insertions(+)
 create mode 100644 web-v2/src/pages/InspectionVisitEditorF4Page.tsx

diff --git a/web-v2/src/pages/InspectionVisitEditorF4Page.tsx b/web-v2/src/pages/InspectionVisitEditorF4Page.tsx
new file mode 100644
index 0000000..ab3280a
--- /dev/null
+++ b/web-v2/src/pages/InspectionVisitEditorF4Page.tsx
@@ -0,0 +1,361 @@
+import { useEffect, useMemo, useState } from 'react';
+import type { FormEvent } from 'react';
+import { Link, useNavigate, useParams } from 'react-router';
+import { useAuth } from '../auth/AuthContext';
+import { Alert, EmptyState, LoadingBlock, errorMessage } from '../components/Feedback';
+import { Icon } from '../components/Icon';
+import { SearchableSelect } from '../components/SearchableSelect';
+import { useOperationalContext } from '../context/OperationalContext';
+import { InspectionActsPanel } from '../features/inspections/InspectionActsPanel';
+import {
+  inspectionStatusClass,
+  inspectionVisitStatusLabel,
+} from '../features/inspections/inspectionPresentation';
+import {
+  createInspectionVisit,
+  excludeInspectionVisitAsset,
+  generateInspectionVisitChecklist,
+  getInspectionVisit,
+  includeInspectionVisitAsset,
+  listAssets,
+  listInspectionAssignees,
+  listInspectionPlanningAreas,
+  listInspectionPlanningOperators,
+  replaceInspectionVisitAssets,
+  replaceInspectionVisitTeam,
+  updateInspectionVisit,
+} from '../lib/api';
+import type {
+  AssetListItem,
+  InspectionPerson,
+  InspectionPlanningContextAsset,
+  InspectionVisit,
+  InspectionVisitAssetPlanningSource,
+} from '../lib/api';
+import {
+  cancelInspectionVisit,
+  planInspectionVisit,
+  unplanInspectionVisit,
+} from '../lib/inspectionVisitLifecycleApi';
+import { formatDate, formatDateOnly } from '../lib/format';
+
+interface VisitForm {
+  objective: string;
+  operationalAreaId: string;
+  operatorCompanyId: string;
+  plannedStartAt: string;
+  instructions: string;
+}
+
+const emptyForm: VisitForm = {
+  objective: '',
+  operationalAreaId: '',
+  operatorCompanyId: '',
+  plannedStartAt: '',
+  instructions: '',
+};
+
+function localDateTime(value: string | null): string {
+  if (!value) return '';
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return '';
+  const local = new Date(parsed.getTime() - parsed.getTimezoneOffset() * 60_000);
+  return local.toISOString().slice(0, 16);
+}
+
+function toIso(value: string): string | null {
+  if (!value) return null;
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+
+function personName(person: InspectionPerson): string {
+  return `${person.firstName} ${person.lastName}`;
+}
+
+function sourceLabel(source: InspectionVisitAssetPlanningSource): string {
+  if (source === 'AUTOMATIC') return 'Checklist automático';
+  if (source === 'PREVENTIVE') return 'Preventivo';
+  if (source === 'VERIFICATION') return 'Verificación';
+  return 'Plan previo';
+}
+
+function checklistLabel(kind: string): string {
+  if (kind === 'VERIFICATION_OVERDUE') return 'Control vencido';
+  if (kind === 'UPCOMING_CONTROL') return 'Próximo control';
+  return 'Antecedente';
+}
+
+export function InspectionVisitEditorF4Page() {
+  const { id } = useParams();
+  const navigate = useNavigate();
+  const { hasPermission } = useAuth();
+  const context = useOperationalContext();
+  const isNew = !id;
+  const canManage = hasPermission('inspections.manage');
+  const canAssign = hasPermission('inspections.assign');
+
+  const [visit, setVisit] = useState<InspectionVisit | null>(null);
+  const [form, setForm] = useState<VisitForm>(emptyForm);
+  const [areas, setAreas] = useState<InspectionPlanningContextAsset[]>([]);
+  const [operators, setOperators] = useState<InspectionPlanningContextAsset[]>([]);
+  const [assignees, setAssignees] = useState<InspectionPerson[]>([]);
+  const [assets, setAssets] = useState<AssetListItem[]>([]);
+  const [assetSearch, setAssetSearch] = useState('');
+  const [newAssetId, setNewAssetId] = useState('');
+  const [leadInspectorId, setLeadInspectorId] = useState('');
+  const [memberIds, setMemberIds] = useState<Set<string>>(new Set());
+  const [loading, setLoading] = useState(!isNew);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState('');
+  const [success, setSuccess] = useState('');
+
+  const applyVisit = (value: InspectionVisit, syncForm = true) => {
+    setVisit(value);
+    setLeadInspectorId(value.leadInspector?.id ?? '');
+    setMemberIds(new Set(value.team.map((member) => member.id)));
+    if (value.operationalArea?.id) {
+      context.setContext(value.operationalArea.id, value.operatorCompany?.id ?? '');
+    }
+    if (syncForm) {
+      setForm({
+        objective: value.objective ?? '',
+        operationalAreaId: value.operationalArea?.id ?? '',
+        operatorCompanyId: value.operatorCompany?.id ?? '',
+        plannedStartAt: localDateTime(value.plannedStartAt),
+        instructions: value.instructions ?? '',
+      });
+    }
+  };
+
+  const reload = async () => {
+    if (!id) return;
+    applyVisit(await getInspectionVisit(id));
+  };
+
+  useEffect(() => {
+    listInspectionPlanningAreas().then(setAreas).catch(() => undefined);
+    if (canAssign) listInspectionAssignees().then(setAssignees).catch(() => undefined);
+  }, [canAssign]);
+
+  useEffect(() => {
+    if (!isNew || form.operationalAreaId || !context.areaId) return;
+    setForm((current) => ({
+      ...current,
+      operationalAreaId: context.areaId,
+      operatorCompanyId: context.companyId,
+    }));
+  }, [isNew, form.operationalAreaId, context.areaId, context.companyId]);
+
+  useEffect(() => {
+    if (!id) return;
+    setLoading(true);
+    reload()
+      .catch((requestError) => setError(errorMessage(requestError)))
+      .finally(() => setLoading(false));
+  }, [id]);
+
+  useEffect(() => {
+    if (!form.operationalAreaId) {
+      setOperators([]);
+      return;
+    }
+    listInspectionPlanningOperators(form.operationalAreaId)
+      .then(setOperators)
+      .catch(() => setOperators([]));
+  }, [form.operationalAreaId]);
+
+  useEffect(() => {
+    if (!form.operationalAreaId || !form.operatorCompanyId) {
+      setAssets([]);
+      return;
+    }
+    const timer = window.setTimeout(() => {
+      listAssets({
+        pageSize: 100,
+        search: assetSearch.trim(),
+        operationalAreaId: form.operationalAreaId,
+        operatorCompanyId: form.operatorCompanyId,
+      }).then((response) => setAssets(response.data)).catch(() => undefined);
+    }, 220);
+    return () => window.clearTimeout(timer);
+  }, [assetSearch, form.operationalAreaId, form.operatorCompanyId]);
+
+  const planningEditable = !visit || visit.status === 'DRAFT' || visit.status === 'PLANNED';
+  const activeAssetIds = useMemo(() => new Set(visit?.assets.map((asset) => asset.id) ?? []), [visit]);
+  const linkedAssetIds = useMemo(() => new Set(visit?.planningAssets.map((asset) => asset.id) ?? []), [visit]);
+  const candidateAssets = assets.filter((asset) => !linkedAssetIds.has(asset.id));
+
+  const saveGeneral = async (event: FormEvent) => {
+    event.preventDefault();
+    setBusy(true);
+    setError('');
+    setSuccess('');
+    try {
+      const plannedStartAt = toIso(form.plannedStartAt);
+      if (isNew) {
+        if (!form.operationalAreaId || !form.operatorCompanyId || !plannedStartAt || !leadInspectorId) {
+          setError('Seleccioná Área, Operadora, fecha de inicio e Inspector.');
+          return;
+        }
+        const created = await createInspectionVisit({
+          operationalAreaId: form.operationalAreaId,
+          operatorCompanyId: form.operatorCompanyId,
+          plannedStartAt,
+          leadInspectorUserId: leadInspectorId,
+        });
+        navigate(`/inspecciones/${created.id}`, { replace: true });
+      } else if (id) {
+        applyVisit(await updateInspectionVisit(id, {
+          objective: form.objective.trim() || null,
+          operationalAreaId: form.operationalAreaId || null,
+          operatorCompanyId: form.operatorCompanyId || null,
+          plannedStartAt,
+          instructions: form.instructions.trim() || null,
+        }));
+        setSuccess('Planificación actualizada. Regenerá el checklist si cambió contexto o fecha.');
+      }
+    } catch (requestError) {
+      setError(errorMessage(requestError));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const regenerateChecklist = async () => {
+    if (!id) return;
+    setBusy(true); setError(''); setSuccess('');
+    try {
+      applyVisit(await generateInspectionVisitChecklist(id), false);
+      setSuccess('Checklist técnico recalculado con antecedentes y controles.');
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setBusy(false); }
+  };
+
+  const addPreventiveAsset = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!id || !newAssetId) return;
+    setBusy(true); setError(''); setSuccess('');
+    try {
+      applyVisit(await replaceInspectionVisitAssets(id, [...activeAssetIds, newAssetId]), false);
+      setNewAssetId('');
+      setSuccess('Registro agregado como preventivo.');
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setBusy(false); }
+  };
+
+  const excludeAsset = async (assetId: string) => {
+    if (!id) return;
+    const reason = window.prompt('Motivo de exclusión (mínimo 10 caracteres). Quedará auditado:')?.trim() ?? '';
+    if (reason.length < 10) {
+      if (reason) setError('El motivo debe tener al menos 10 caracteres.');
+      return;
+    }
+    setBusy(true); setError(''); setSuccess('');
+    try {
+      applyVisit(await excludeInspectionVisitAsset(id, assetId, reason), false);
+      setSuccess('Registro excluido con trazabilidad.');
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setBusy(false); }
+  };
+
+  const reincludeAsset = async (assetId: string) => {
+    if (!id) return;
+    setBusy(true); setError(''); setSuccess('');
+    try {
+      applyVisit(await includeInspectionVisitAsset(id, assetId), false);
+      setSuccess('Registro reincorporado; la exclusión anterior permanece en historial.');
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setBusy(false); }
+  };
+
+  const chooseLead = (value: string) => {
+    setLeadInspectorId(value);
+    if (value) setMemberIds((current) => new Set([...current, value]));
+  };
+
+  const saveTeam = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!id) return;
+    const nextMembers = new Set(memberIds);
+    if (leadInspectorId) nextMembers.add(leadInspectorId);
+    setBusy(true); setError(''); setSuccess('');
+    try {
+      applyVisit(await replaceInspectionVisitTeam(id, leadInspectorId || null, [...nextMembers]), false);
+      setSuccess('Equipo actualizado.');
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setBusy(false); }
+  };
+
+  const lifecycleAction = async (action: 'PLAN' | 'UNPLAN' | 'CANCEL') => {
+    if (!id) return;
+    setBusy(true); setError(''); setSuccess('');
+    try {
+      let updated: InspectionVisit;
+      if (action === 'PLAN') {
+        updated = await planInspectionVisit(id);
+        setSuccess('Inspección planificada. Ya puede iniciarse desde la APK.');
+      } else if (action === 'UNPLAN') {
+        updated = await unplanInspectionVisit(id);
+        setSuccess('La Inspección volvió a borrador para corregir la planificación.');
+      } else {
+        const reason = window.prompt('Indicá el motivo de cancelación (mínimo 10 caracteres):')?.trim() ?? '';
+        if (reason.length < 10) {
+          if (reason) setError('El motivo debe tener al menos 10 caracteres.');
+          return;
+        }
+        updated = await cancelInspectionVisit(id, reason);
+        setSuccess('Inspección cancelada con motivo auditado.');
+      }
+      applyVisit(updated);
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setBusy(false); }
+  };
+
+  if (loading) return <LoadingBlock label="Cargando inspección…" />;
+
+  return <section className="survey-editor inspection-editor">
+    <div className="breadcrumb"><Link to="/inspecciones">Inspecciones</Link><span>/</span><span>{isNew ? 'Planificar inspección' : visit?.code ?? 'Detalle'}</span></div>
+    <div className="page-heading survey-editor-heading">
+      <div><span className="eyebrow">INSPECCIÓN</span><h1>{isNew ? 'Planificar inspección' : visit?.code ?? 'Inspección'}</h1><p>{isNew ? 'Área, Operadora, inicio e Inspector. El identificador se genera automáticamente.' : `${visit?.operationalArea?.name ?? 'Sin Área'} · ${visit?.operatorCompany?.name ?? 'Sin Operadora'} · ${visit?.assetCount ?? 0} registros`}</p></div>
+      {visit && <span className={`status-badge large ${inspectionStatusClass(visit.status)}`}>{inspectionVisitStatusLabel(visit.status)}</span>}
+    </div>
+    {error && <Alert>{error}</Alert>}{success && <Alert type="success">{success}</Alert>}
+
+    <form className={`panel form-panel ${isNew ? 'inspection-quick-create' : ''}`} onSubmit={saveGeneral}>
+      <div className="panel-heading"><div><span className="eyebrow">{isNew ? 'CREACIÓN RÁPIDA' : 'PLANIFICACIÓN'}</span><h2>Contexto y fecha de inicio</h2><p className="section-copy">No existe título independiente ni fecha de fin planificada. El cierre real se registra al terminar el trabajo de campo.</p></div>{visit && <small className="muted">Actualizado {formatDate(visit.updatedAt)}</small>}</div>
+      {visit && <div className="inspection-generated-code"><small>Identificador institucional</small><strong>{visit.code}</strong></div>}
+      <div className="form-grid">
+        <label className="field"><span>Área / Yacimiento</span><SearchableSelect searchPlaceholder="Buscar Área…" value={form.operationalAreaId} onChange={(event) => { context.setAreaId(event.target.value); setForm((current) => ({ ...current, operationalAreaId: event.target.value, operatorCompanyId: '' })); }} required disabled={!canManage || !planningEditable}><option value="">Seleccionar Área…</option>{areas.map((area) => <option key={area.id} value={area.id}>{area.name} · {area.code}</option>)}</SearchableSelect></label>
+        <label className="field"><span>Operadora</span><SearchableSelect searchPlaceholder="Buscar Operadora…" value={form.operatorCompanyId} onChange={(event) => { context.setCompanyId(event.target.value); setForm((current) => ({ ...current, operatorCompanyId: event.target.value })); }} required disabled={!canManage || !planningEditable || !form.operationalAreaId}><option value="">Seleccionar Operadora…</option>{operators.map((operator) => <option key={operator.id} value={operator.id}>{operator.name} · {operator.code}</option>)}</SearchableSelect></label>
+        <label className="field"><span>Fecha y hora de inicio</span><input type="datetime-local" value={form.plannedStartAt} onChange={(event) => setForm((current) => ({ ...current, plannedStartAt: event.target.value }))} required disabled={!canManage || !planningEditable} /></label>
+        {isNew && <label className="field"><span>Inspector responsable</span><SearchableSelect searchPlaceholder="Buscar Inspector…" value={leadInspectorId} onChange={(event) => setLeadInspectorId(event.target.value)} required disabled={!canAssign}><option value="">Seleccionar Inspector…</option>{assignees.map((person) => <option key={person.id} value={person.id}>{personName(person)} · {person.username}</option>)}</SearchableSelect></label>}
+      </div>
+      {!isNew && <><label className="field"><span>Objetivo <em>opcional</em></span><textarea rows={2} maxLength={4000} value={form.objective} onChange={(event) => setForm((current) => ({ ...current, objective: event.target.value }))} disabled={!canManage || !planningEditable} /></label><label className="field"><span>Instrucciones <em>opcional</em></span><textarea rows={2} maxLength={4000} value={form.instructions} onChange={(event) => setForm((current) => ({ ...current, instructions: event.target.value }))} disabled={!canManage || !planningEditable} /></label></>}
+      {canManage && planningEditable && <div className="form-actions"><Link className="button secondary" to="/inspecciones">Volver</Link><button className="button primary" disabled={busy || (isNew && (!canAssign || !leadInspectorId))}><Icon name="check" />{isNew ? 'Crear inspección' : 'Guardar planificación'}</button></div>}
+    </form>
+
+    {visit && <article className="panel inspection-checklist-panel">
+      <div className="panel-heading"><div><span className="eyebrow">CHECKLIST TÉCNICO</span><h2>Antecedentes y controles</h2><p className="section-copy">Se construye por Área, Operadora y fecha. Las respuestas administrativas de empresa no modifican este checklist.</p></div>{canManage && planningEditable && <button type="button" className="button secondary" onClick={() => void regenerateChecklist()} disabled={busy}>Regenerar checklist</button>}</div>
+      {visit.checklist.stale && <Alert>El contexto o la fecha cambió. Regenerá el checklist antes de planificar.</Alert>}
+      <div className="inspection-checklist-metrics"><div><strong>{visit.checklist.verificationOverdue}</strong><span>controles vencidos</span></div><div><strong>{visit.checklist.upcomingControls}</strong><span>próximos 30 días</span></div><div><strong>{visit.checklist.antecedents}</strong><span>antecedentes</span></div><div><strong>{visit.checklist.actionableAssets}</strong><span>registros sugeridos</span></div></div>
+      {visit.checklist.items.length === 0 ? <EmptyState title="Sin antecedentes" text="No hay Hallazgos históricos técnicos para este contexto." /> : <div className="table-scroll"><table><thead><tr><th>Tipo</th><th>Hallazgo</th><th>Inventario</th><th>Fecha</th><th>Gravedad</th></tr></thead><tbody>{visit.checklist.items.map((item) => <tr key={item.id}><td><span className={`status-badge ${item.itemKind === 'ANTECEDENT' ? '' : 'warning'}`}>{checklistLabel(item.itemKind)}</span></td><td><Link className="history-asset-link" to={`/hallazgos/${item.findingId}`}><strong>{item.findingTitle}</strong><small>{item.findingCode}</small></Link></td><td><Link className="history-asset-link" to={`/inventarios/${item.asset.id}`}><strong>{item.asset.name}</strong><small>{item.asset.code} · {item.asset.typeName}</small></Link></td><td>{formatDateOnly(item.referenceOn)}</td><td>{item.severity ?? '—'}</td></tr>)}</tbody></table></div>}
+    </article>}
+
+    {visit && visit.verificationFindings.length > 0 && <article className="panel verification-visit-findings"><div className="panel-heading"><div><span className="eyebrow">VERIFICACIÓN</span><h2>Hallazgos a controlar</h2></div><span className="count-pill">{visit.verificationFindings.length}</span></div><div className="dossier-link-list">{visit.verificationFindings.map((finding) => <Link key={finding.id} to={`/hallazgos/${finding.id}`}><div><strong>{finding.title}</strong><small>{finding.code} · {finding.assetName} · objetivo {formatDateOnly(finding.targetControlOn ?? finding.nextControlOn)}</small>{finding.resultNotes && <small>{finding.resultNotes}</small>}</div><span>{finding.outcome === 'RESOLVED' ? 'Solucionado' : finding.outcome === 'NOT_RESOLVED' ? 'No solucionado' : finding.outcome === 'REQUIRES_NEW_DATE' ? 'Reprogramar' : 'Pendiente'}</span><Icon name="chevron" size={16} /></Link>)}</div></article>}
+
+    {visit && planningEditable && canManage && <form className="panel survey-add-target" onSubmit={addPreventiveAsset}><div className="panel-heading"><div><span className="eyebrow">PREVENTIVO</span><h2>Agregar Inventario sin pendiente previo</h2></div></div><label className="field"><span>Buscar Inventario</span><input value={assetSearch} onChange={(event) => setAssetSearch(event.target.value)} placeholder="Código o nombre" /></label><label className="field"><span>Inventario</span><SearchableSelect value={newAssetId} onChange={(event) => setNewAssetId(event.target.value)} required><option value="">Seleccionar…</option>{candidateAssets.map((asset) => <option key={asset.id} value={asset.id}>{asset.code} · {asset.name} · {asset.type.name}</option>)}</SearchableSelect></label><div className="form-actions"><button className="button primary" disabled={busy || !newAssetId}><Icon name="plus" />Agregar preventivo</button></div></form>}
+
+    {visit && <article className="table-panel inspection-assets"><div className="table-summary"><strong>{visit.assets.length} incluidos</strong><span>{visit.checklist.excludedAssets} excluidos con trazabilidad</span></div>{visit.planningAssets.length === 0 ? <EmptyState title="Sin Inventarios" text="Generá el checklist o agregá un preventivo." /> : <div className="table-scroll"><table><thead><tr><th>Inventario</th><th>Origen</th><th>Estado</th><th>Motivo</th><th /></tr></thead><tbody>{visit.planningAssets.map((asset) => <tr key={asset.id}><td><Link className="history-asset-link" to={`/inventarios/${asset.id}`}><strong>{asset.name}</strong><small>{asset.code} · {asset.typeName}</small></Link></td><td>{sourceLabel(asset.planningSource)}</td><td>{asset.included ? 'Incluido' : 'Excluido'}</td><td>{asset.exclusionReason ?? '—'}</td><td>{canManage && planningEditable && (asset.included ? <button type="button" className="button danger-outline compact" onClick={() => void excludeAsset(asset.id)}>Excluir</button> : <button type="button" className="button secondary compact" onClick={() => void reincludeAsset(asset.id)}>Reincorporar</button>)}</td></tr>)}</tbody></table></div>}</article>}
+
+    {visit && canAssign && planningEditable && <form className="panel inspection-team-panel" onSubmit={saveTeam}><div className="panel-heading"><div><span className="eyebrow">EQUIPO</span><h2>Inspectores asignados</h2></div></div><label className="field"><span>Inspector responsable</span><SearchableSelect value={leadInspectorId} onChange={(event) => chooseLead(event.target.value)}><option value="">Seleccionar…</option>{assignees.map((person) => <option key={person.id} value={person.id}>{personName(person)} · {person.username}</option>)}</SearchableSelect></label><div className="inspection-team-grid">{assignees.map((person) => <label className={`inspection-member ${memberIds.has(person.id) ? 'selected' : ''}`} key={person.id}><input type="checkbox" checked={memberIds.has(person.id)} onChange={() => setMemberIds((current) => { const next = new Set(current); next.has(person.id) ? next.delete(person.id) : next.add(person.id); return next; })} disabled={person.id === leadInspectorId} /><span><strong>{personName(person)}</strong><small>{person.username}{person.id === leadInspectorId ? ' · Responsable' : ''}</small></span></label>)}</div><div className="form-actions"><button className="button primary" disabled={busy || !leadInspectorId}>Guardar equipo</button></div></form>}
+
+    {visit && <InspectionActsPanel visit={visit} />}
+
+    {visit && <article className="panel survey-status-actions"><div><strong>Flujo de la Inspección</strong><p>La oficina planifica. El inicio y cierre operativo se realizan desde la APK. Una Inspección no puede cerrarse hasta que todas sus Actas estén selladas.</p></div><div className="form-actions">{canManage && visit.status === 'DRAFT' && <button type="button" className="button primary" disabled={busy} onClick={() => void lifecycleAction('PLAN')}>Confirmar planificación</button>}{canManage && visit.status === 'PLANNED' && <button type="button" className="button secondary" disabled={busy} onClick={() => void lifecycleAction('UNPLAN')}>Volver a borrador</button>}{canManage && ['DRAFT', 'PLANNED'].includes(visit.status) && <button type="button" className="button danger-outline" disabled={busy} onClick={() => void lifecycleAction('CANCEL')}>Cancelar</button>}</div></article>}
+
+    {visit?.status === 'PLANNED' && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Planificación lista.</strong> El Inspector asignado debe iniciar la Inspección desde la APK.</p></div>}
+    {visit?.status === 'IN_PROGRESS' && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Inspección en curso.</strong> Actas, Hallazgos, firmas y cierre se registran desde la APK.</p></div>}
+    {visit?.status === 'CANCELLED' && <Alert>Cancelada: {visit.cancellationReason}</Alert>}
+  </section>;
+}

From 7ac42fa05d91a6d1a9035446a22c098842c74eb0 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:10:36 -0300
Subject: [PATCH 107/224] F4: route inspections through clean planning editor

---
 web-v2/src/app/App.tsx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/web-v2/src/app/App.tsx b/web-v2/src/app/App.tsx
index 79531b0..c38e77d 100644
--- a/web-v2/src/app/App.tsx
+++ b/web-v2/src/app/App.tsx
@@ -22,7 +22,7 @@ import { InventoryFunctionsPage } from '../pages/InventoryFunctionsPage';
 import { HistoryPage } from '../pages/HistoryPage';
 import { TemporalAssetsPage } from '../pages/TemporalAssetsPage';
 import { InspectionVisitsPage } from '../pages/InspectionVisitsPage';
-import { InspectionVisitEditorPage } from '../pages/InspectionVisitEditorPage';
+import { InspectionVisitEditorF4Page } from '../pages/InspectionVisitEditorF4Page';
 import { InspectionActEditorPage } from '../pages/InspectionActEditorPage';
 import { FindingCatalogPage } from '../pages/FindingCatalogPage';
 import { FindingDetailPage } from '../pages/FindingDetailPage';
@@ -62,10 +62,10 @@ export function App() {
         <Route path="/relevamiento/*" element={<Navigate to="/inventarios" replace />} />
         <Route element={<PermissionRoute permission="inspections.read" />}>
           <Route path="/inspecciones" element={<InspectionVisitsPage />} />
-          <Route path="/inspecciones/:id" element={<InspectionVisitEditorPage />} />
+          <Route path="/inspecciones/:id" element={<InspectionVisitEditorF4Page />} />
           <Route path="/preparacion-campo" element={<FieldBriefingsPage />} />
         </Route>
-        <Route element={<PermissionRoute permission="inspections.manage" />}><Route path="/inspecciones/nueva" element={<InspectionVisitEditorPage />} /></Route>
+        <Route element={<PermissionRoute permission="inspections.manage" />}><Route path="/inspecciones/nueva" element={<InspectionVisitEditorF4Page />} /></Route>
         <Route element={<PermissionRoute permission="inspection_acts.read" />}>
           <Route path="/inspecciones/actas/:actId" element={<InspectionActEditorPage />} />
           <Route path="/inspecciones/actas/nueva" element={<InspectionActEditorPage />} />

From 5996c3819abc2224e64898ed3b218e0a6052c1c0 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:10:48 -0300
Subject: [PATCH 108/224] F4: remove obsolete generic-status inspection editor

---
 .../src/pages/InspectionVisitEditorPage.tsx   | 410 ------------------
 1 file changed, 410 deletions(-)
 delete mode 100644 web-v2/src/pages/InspectionVisitEditorPage.tsx

diff --git a/web-v2/src/pages/InspectionVisitEditorPage.tsx b/web-v2/src/pages/InspectionVisitEditorPage.tsx
deleted file mode 100644
index 223e655..0000000
--- a/web-v2/src/pages/InspectionVisitEditorPage.tsx
+++ /dev/null
@@ -1,410 +0,0 @@
-import { SearchableSelect } from '../components/SearchableSelect';
-import { useEffect, useMemo, useState } from 'react';
-import type { FormEvent } from 'react';
-import { Link, useNavigate, useParams } from 'react-router';
-import { useAuth } from '../auth/AuthContext';
-import { Alert, EmptyState, LoadingBlock, errorMessage } from '../components/Feedback';
-import { Icon } from '../components/Icon';
-import { useOperationalContext } from '../context/OperationalContext';
-import {
-  inspectionStatusClass,
-  inspectionVisitStatusLabel,
-} from '../features/inspections/inspectionPresentation';
-import { InspectionActsPanel } from '../features/inspections/InspectionActsPanel';
-import {
-  createInspectionVisit,
-  excludeInspectionVisitAsset,
-  generateInspectionVisitChecklist,
-  getInspectionVisit,
-  includeInspectionVisitAsset,
-  listAssets,
-  listInspectionAssignees,
-  listInspectionPlanningAreas,
-  listInspectionPlanningOperators,
-  replaceInspectionVisitAssets,
-  replaceInspectionVisitTeam,
-  updateInspectionVisit,
-  updateInspectionVisitStatus,
-} from '../lib/api';
-import type {
-  AssetListItem,
-  InspectionChecklistItemKind,
-  InspectionPerson,
-  InspectionPlanningContextAsset,
-  InspectionVisit,
-  InspectionVisitAssetPlanningSource,
-  InspectionVisitStatus,
-} from '../lib/api';
-import { formatDate, formatDateOnly } from '../lib/format';
-
-interface VisitForm {
-  objective: string;
-  operationalAreaId: string;
-  operatorCompanyId: string;
-  plannedStartAt: string;
-  instructions: string;
-}
-
-const emptyVisit: VisitForm = {
-  objective: '',
-  operationalAreaId: '',
-  operatorCompanyId: '',
-  plannedStartAt: '',
-  instructions: '',
-};
-
-function localDateTime(value: string | null): string {
-  if (!value) return '';
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return '';
-  const local = new Date(date.getTime() - date.getTimezoneOffset() * 60_000);
-  return local.toISOString().slice(0, 16);
-}
-
-function isoOrNull(value: string): string | null {
-  return value ? new Date(value).toISOString() : null;
-}
-
-function personName(person: InspectionPerson): string {
-  return `${person.firstName} ${person.lastName}`;
-}
-
-function sourceLabel(source: InspectionVisitAssetPlanningSource): string {
-  if (source === 'AUTOMATIC') return 'Checklist automático';
-  if (source === 'PREVENTIVE') return 'Preventivo';
-  if (source === 'VERIFICATION') return 'Verificación';
-  return 'Plan previo';
-}
-
-function checklistLabel(kind: InspectionChecklistItemKind): string {
-  if (kind === 'COMPANY_OVERDUE') return 'Respuesta vencida';
-  if (kind === 'VERIFICATION_OVERDUE') return 'Control vencido';
-  if (kind === 'UPCOMING_CONTROL') return 'Próximo control';
-  return 'Antecedente';
-}
-
-export function InspectionVisitEditorPage() {
-  const { id } = useParams();
-  const navigate = useNavigate();
-  const { hasPermission } = useAuth();
-  const operationalContext = useOperationalContext();
-  const isNew = !id;
-  const canManage = hasPermission('inspections.manage');
-  const canAssign = hasPermission('inspections.assign');
-  const [visit, setVisit] = useState<InspectionVisit | null>(null);
-  const [form, setForm] = useState<VisitForm>(emptyVisit);
-  const [areas, setAreas] = useState<InspectionPlanningContextAsset[]>([]);
-  const [operators, setOperators] = useState<InspectionPlanningContextAsset[]>([]);
-  const [assets, setAssets] = useState<AssetListItem[]>([]);
-  const [assignees, setAssignees] = useState<InspectionPerson[]>([]);
-  const [assetSearch, setAssetSearch] = useState('');
-  const [newAssetId, setNewAssetId] = useState('');
-  const [leadInspectorId, setLeadInspectorId] = useState('');
-  const [memberIds, setMemberIds] = useState<Set<string>>(new Set());
-  const [loading, setLoading] = useState(!isNew);
-  const [busy, setBusy] = useState(false);
-  const [error, setError] = useState('');
-  const [success, setSuccess] = useState('');
-
-  const applyVisit = (value: InspectionVisit, syncGeneral = true) => {
-    setVisit(value);
-    if (value.operationalArea?.id) operationalContext.setContext(value.operationalArea.id, value.operatorCompany?.id ?? '');
-    setLeadInspectorId(value.leadInspector?.id ?? '');
-    setMemberIds(new Set(value.team.map((member) => member.id)));
-    if (syncGeneral) {
-      setForm({
-        objective: value.objective ?? '',
-        operationalAreaId: value.operationalArea?.id ?? '',
-        operatorCompanyId: value.operatorCompany?.id ?? '',
-        plannedStartAt: localDateTime(value.plannedStartAt),
-        instructions: value.instructions ?? '',
-      });
-    }
-  };
-
-  useEffect(() => {
-    listInspectionPlanningAreas().then(setAreas).catch(() => undefined);
-  }, []);
-
-  useEffect(() => {
-    if (!isNew || form.operationalAreaId || !operationalContext.areaId) return;
-    setForm((current) => ({
-      ...current,
-      operationalAreaId: operationalContext.areaId,
-      operatorCompanyId: operationalContext.companyId,
-    }));
-  }, [isNew, form.operationalAreaId, operationalContext.areaId, operationalContext.companyId]);
-
-  useEffect(() => {
-    if (!id) return;
-    setLoading(true);
-    getInspectionVisit(id)
-      .then((value) => applyVisit(value))
-      .catch((requestError) => setError(errorMessage(requestError)))
-      .finally(() => setLoading(false));
-  }, [id]);
-
-  useEffect(() => {
-    if (!form.operationalAreaId) {
-      setOperators([]);
-      return;
-    }
-    listInspectionPlanningOperators(form.operationalAreaId)
-      .then(setOperators)
-      .catch(() => setOperators([]));
-  }, [form.operationalAreaId]);
-
-  useEffect(() => {
-    if (!form.operationalAreaId || !form.operatorCompanyId) {
-      setAssets([]);
-      return;
-    }
-    const timer = window.setTimeout(() => {
-      listAssets({
-        pageSize: 100,
-        search: assetSearch.trim(),
-        operationalAreaId: form.operationalAreaId,
-        operatorCompanyId: form.operatorCompanyId,
-      })
-        .then((response) => setAssets(response.data))
-        .catch(() => undefined);
-    }, 220);
-    return () => window.clearTimeout(timer);
-  }, [assetSearch, form.operationalAreaId, form.operatorCompanyId]);
-
-  useEffect(() => {
-    if (!canAssign) return;
-    listInspectionAssignees().then(setAssignees).catch(() => undefined);
-  }, [canAssign]);
-
-  const planningEditable = !visit || visit.status === 'DRAFT' || visit.status === 'PLANNED';
-  const activeAssetIds = useMemo(
-    () => new Set(visit?.assets.map((asset) => asset.id) ?? []),
-    [visit],
-  );
-  const linkedAssetIds = useMemo(
-    () => new Set(visit?.planningAssets.map((asset) => asset.id) ?? []),
-    [visit],
-  );
-  const candidateAssets = assets.filter((asset) => !linkedAssetIds.has(asset.id));
-
-  const saveGeneral = async (event: FormEvent) => {
-    event.preventDefault();
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      if (isNew) {
-        const plannedStartAt = isoOrNull(form.plannedStartAt);
-        if (!form.operationalAreaId || !form.operatorCompanyId || !plannedStartAt || !leadInspectorId) {
-          setError('Seleccioná Área, Operadora, fecha de inicio e Inspector.');
-          return;
-        }
-        const created = await createInspectionVisit({
-          operationalAreaId: form.operationalAreaId,
-          operatorCompanyId: form.operatorCompanyId,
-          plannedStartAt,
-          leadInspectorUserId: leadInspectorId,
-        });
-        navigate(`/inspecciones/${created.id}`, { replace: true });
-      } else if (id) {
-        applyVisit(await updateInspectionVisit(id, {
-          objective: form.objective || null,
-          operationalAreaId: form.operationalAreaId || null,
-          operatorCompanyId: form.operatorCompanyId || null,
-          plannedStartAt: isoOrNull(form.plannedStartAt),
-          instructions: form.instructions || null,
-        }));
-        setSuccess('Planificación actualizada. Si cambió el contexto o la fecha, regenerá el checklist.');
-      }
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const generateChecklist = async () => {
-    if (!id) return;
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      applyVisit(await generateInspectionVisitChecklist(id), false);
-      setSuccess('Checklist recalculado con antecedentes, vencidos y próximos controles.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const addPreventiveAsset = async (event: FormEvent) => {
-    event.preventDefault();
-    if (!id || !visit || !newAssetId) return;
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      applyVisit(await replaceInspectionVisitAssets(id, [...activeAssetIds, newAssetId]), false);
-      setNewAssetId('');
-      setSuccess('Registro agregado como inspección preventiva.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const excludeAsset = async (assetId: string) => {
-    if (!id) return;
-    const reason = window.prompt('Motivo de exclusión (mínimo 10 caracteres). Quedará auditado:')?.trim() || '';
-    if (reason.length < 10) {
-      if (reason) setError('El motivo de exclusión debe tener al menos 10 caracteres.');
-      return;
-    }
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      applyVisit(await excludeInspectionVisitAsset(id, assetId, reason), false);
-      setSuccess('Registro excluido con motivo auditado.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const reincludeAsset = async (assetId: string) => {
-    if (!id) return;
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      applyVisit(await includeInspectionVisitAsset(id, assetId), false);
-      setSuccess('Registro reincorporado; la exclusión anterior permanece en auditoría.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const chooseLead = (value: string) => {
-    setLeadInspectorId(value);
-    if (value) setMemberIds((current) => new Set([...current, value]));
-  };
-
-  const saveTeam = async (event: FormEvent) => {
-    event.preventDefault();
-    if (!id) return;
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      const nextMembers = new Set(memberIds);
-      if (leadInspectorId) nextMembers.add(leadInspectorId);
-      applyVisit(await replaceInspectionVisitTeam(
-        id,
-        leadInspectorId || null,
-        [...nextMembers],
-      ), false);
-      setSuccess('Equipo de inspección actualizado.');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const changeStatus = async (status: InspectionVisitStatus) => {
-    if (!id) return;
-    let reason: string | null = null;
-    if (status === 'CANCELLED') {
-      reason = window.prompt('Indicá el motivo de cancelación (mínimo 10 caracteres):')?.trim() || null;
-      if (!reason) return;
-    }
-    setBusy(true);
-    setError('');
-    setSuccess('');
-    try {
-      applyVisit(await updateInspectionVisitStatus(id, status, reason));
-      setSuccess(`Visita ${inspectionVisitStatusLabel(status).toLocaleLowerCase('es-AR')}.`);
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  if (loading) return <LoadingBlock label="Cargando inspección…" />;
-
-  return <section className="survey-editor inspection-editor">
-    <div className="breadcrumb"><Link to="/inspecciones">Inspecciones</Link><span>/</span><span>{isNew ? 'Planificar inspección' : visit?.code ?? 'Detalle'}</span></div>
-    <div className="page-heading survey-editor-heading"><div><span className="eyebrow">INSPECCIÓN</span><h1>{isNew ? 'Planificar inspección' : visit?.code ?? 'Inspección'}</h1><p>{isNew ? 'Cuatro datos y listo. El código y el checklist se generan automáticamente.' : `${visit?.operationalArea?.name ?? 'Sin Área'} · ${visit?.operatorCompany?.name ?? 'Sin Operadora'} · ${visit?.assetCount ?? 0} registros`}</p></div>{visit && <span className={`status-badge large ${inspectionStatusClass(visit.status)}`}>{inspectionVisitStatusLabel(visit.status)}</span>}</div>
-    {error && <Alert>{error}</Alert>}{success && <Alert type="success">{success}</Alert>}
-
-    <form className={`panel form-panel ${isNew ? 'inspection-quick-create' : ''}`} onSubmit={saveGeneral}>
-      <div className="panel-heading"><div><span className="eyebrow">{isNew ? 'CREACIÓN RÁPIDA' : 'PLANIFICACIÓN'}</span><h2>{isNew ? '¿Dónde y cuándo se inspecciona?' : 'Contexto y fecha de inicio'}</h2><p className="section-copy">{isNew ? 'El código se asigna automáticamente. No hay título ni fecha de fin planificada.' : 'La inspección conserva una única fecha de inicio planificada; el cierre real se registra al finalizar en campo.'}</p></div>{visit && <small className="muted">Actualizado {formatDate(visit.updatedAt)}</small>}</div>
-      {!isNew && <div className="inspection-generated-code"><small>Código automático</small><strong>{visit?.code}</strong></div>}
-      <div className="form-grid">
-        <label className="field"><span>Área</span><SearchableSelect searchPlaceholder="Buscar Área…" value={form.operationalAreaId} onChange={(event) => { operationalContext.setAreaId(event.target.value); setForm((current) => ({ ...current, operationalAreaId: event.target.value, operatorCompanyId: '' })); }} required disabled={!canManage || !planningEditable}><option value="">Seleccionar Área…</option>{visit?.operationalArea && !areas.some((area) => area.id === visit.operationalArea?.id) && <option value={visit.operationalArea.id}>{visit.operationalArea.name} · {visit.operationalArea.code}</option>}{areas.map((area) => <option key={area.id} value={area.id}>{area.name} · {area.code}</option>)}</SearchableSelect></label>
-        <label className="field"><span>Operadora</span><SearchableSelect searchPlaceholder="Buscar Operadora…" value={form.operatorCompanyId} onChange={(event) => { operationalContext.setCompanyId(event.target.value); setForm((current) => ({ ...current, operatorCompanyId: event.target.value })); }} required disabled={!canManage || !planningEditable || !form.operationalAreaId}><option value="">{form.operationalAreaId ? 'Seleccionar Operadora…' : 'Primero seleccioná un Área'}</option>{visit?.operatorCompany && !operators.some((operator) => operator.id === visit.operatorCompany?.id) && <option value={visit.operatorCompany.id}>{visit.operatorCompany.name} · {visit.operatorCompany.code}</option>}{operators.map((operator) => <option key={operator.id} value={operator.id}>{operator.name} · {operator.code}</option>)}</SearchableSelect><small>Sólo operadoras vigentes para el Área elegida.</small></label>
-        <label className="field"><span>Fecha y hora de inicio</span><input type="datetime-local" value={form.plannedStartAt} onChange={(event) => setForm((current) => ({ ...current, plannedStartAt: event.target.value }))} required disabled={!canManage || !planningEditable} /></label>
-        {isNew && <label className="field"><span>Inspector</span><SearchableSelect searchPlaceholder="Buscar Inspector…" value={leadInspectorId} onChange={(event) => setLeadInspectorId(event.target.value)} required disabled={!canAssign}><option value="">Seleccionar Inspector…</option>{assignees.map((person) => <option key={person.id} value={person.id}>{personName(person)} · {person.username}</option>)}</SearchableSelect></label>}
-      </div>
-      {!isNew && <><label className="field"><span>Objetivo <em>opcional</em></span><textarea rows={2} value={form.objective} onChange={(event) => setForm((current) => ({ ...current, objective: event.target.value }))} maxLength={4000} disabled={!canManage || !planningEditable} /></label><label className="field"><span>Instrucciones <em>opcional</em></span><textarea rows={2} value={form.instructions} onChange={(event) => setForm((current) => ({ ...current, instructions: event.target.value }))} maxLength={4000} disabled={!canManage || !planningEditable} /></label></>}
-      {canManage && planningEditable && <div className="form-actions"><Link className="button secondary" to="/inspecciones">Cancelar</Link><button className="button primary" disabled={busy || (isNew && (!canAssign || !form.operationalAreaId || !form.operatorCompanyId || !form.plannedStartAt || !leadInspectorId))}><Icon name="check" />{isNew ? (busy ? 'Creando…' : 'Crear inspección') : 'Guardar planificación'}</button></div>}
-    </form>
-
-    {visit && <article className="panel inspection-checklist-panel">
-      <div className="panel-heading"><div><span className="eyebrow">CHECKLIST AUTOMÁTICO</span><h2>Antecedentes y próximas acciones</h2><p className="section-copy">Se calcula para el Área, Operadora y fecha del plan. Las generaciones anteriores quedan preservadas.</p></div><div className="form-actions">{canManage && planningEditable && <button type="button" className="button secondary" onClick={() => void generateChecklist()} disabled={busy}><Icon name="check" />{visit.checklist.generation ? 'Regenerar checklist' : 'Generar checklist'}</button>}</div></div>
-      {visit.checklist.stale && <Alert>El contexto o la fecha cambió después de la última generación. Regenerá el checklist antes de confirmar.</Alert>}
-      {!visit.checklist.generatedAt && visit.checklist.generation === 0 && <Alert>El checklist todavía no fue generado. Al confirmar la planificación el servidor también exige una versión vigente.</Alert>}
-      <div className="inspection-checklist-metrics">
-        <div><strong>{visit.checklist.companyOverdue}</strong><span>respuestas vencidas</span></div>
-        <div><strong>{visit.checklist.verificationOverdue}</strong><span>controles vencidos</span></div>
-        <div><strong>{visit.checklist.upcomingControls}</strong><span>próximos 30 días</span></div>
-        <div><strong>{visit.checklist.antecedents}</strong><span>antecedentes</span></div>
-        <div><strong>{visit.checklist.actionableAssets}</strong><span>registros sugeridos</span></div>
-      </div>
-      {visit.checklist.generatedAt && <small className="muted">Generación {visit.checklist.generation} · {formatDate(visit.checklist.generatedAt)}</small>}
-      {visit.checklist.items.length === 0 ? <EmptyState title="Sin antecedentes" text="No hay hallazgos históricos para el contexto seleccionado. Podés agregar registros preventivos." /> : <div className="table-scroll"><table><thead><tr><th>Prioridad</th><th>Hallazgo</th><th>Registro</th><th>Fecha</th><th>Gravedad</th></tr></thead><tbody>{visit.checklist.items.map((item) => <tr key={item.id}><td><span className={`status-badge ${item.itemKind === 'ANTECEDENT' ? '' : 'warning'}`}>{checklistLabel(item.itemKind)}</span></td><td><Link className="history-asset-link" to={`/hallazgos/${item.findingId}`}><strong>{item.findingTitle}</strong><small>{item.findingCode} · {item.findingStatus}</small></Link></td><td><Link className="history-asset-link" to={`/inventarios/${item.asset.id}`}><strong>{item.asset.name}</strong><small>{item.asset.code} · {item.asset.typeName}</small></Link></td><td>{item.referenceOn ? formatDateOnly(item.referenceOn) : '—'}</td><td>{item.severity ?? '—'}</td></tr>)}</tbody></table></div>}
-    </article>}
-
-    {visit && visit.verificationFindings.length > 0 && <article className="panel verification-visit-findings">
-      <div className="panel-heading"><div><span className="eyebrow">VERIFICACIÓN DE HALLAZGOS</span><h2>Hallazgos a controlar</h2><p className="section-copy">Esta inspección nació desde una planificación de verificación y conserva ese vínculo histórico.</p></div><span className="count-pill">{visit.verificationFindings.length}</span></div>
-      <div className="dossier-link-list">{visit.verificationFindings.map((finding) => {
-        const outcome = finding.outcome === 'RESOLVED' ? 'Solucionado' : finding.outcome === 'NOT_RESOLVED' ? 'No solucionado' : finding.outcome === 'REQUIRES_NEW_DATE' ? 'Nueva fecha requerida' : visit.status === 'IN_PROGRESS' ? 'Pendiente de resultado' : 'Abrir seguimiento';
-        return <Link key={finding.id} to={`/hallazgos/${finding.id}`}><div><strong>{finding.title}</strong><small>{finding.code} · {finding.assetName} · objetivo {formatDateOnly(finding.targetControlOn ?? finding.nextControlOn)}{finding.verificationEvidenceCount ? ` · ${finding.verificationEvidenceCount} foto${finding.verificationEvidenceCount === 1 ? '' : 's'}` : ''}</small>{finding.resultNotes && <small>{finding.resultNotes}</small>}{finding.rescheduledControlOn && <small>Nuevo control: {formatDateOnly(finding.rescheduledControlOn)}</small>}</div><span>{finding.status === 'CLOSED' ? 'Cerrado' : outcome}</span><Icon name="chevron" size={16} /></Link>;
-      })}</div>
-    </article>}
-
-    {visit && planningEditable && canManage && <form className="panel survey-add-target" onSubmit={addPreventiveAsset}>
-      <div className="panel-heading"><div><span className="eyebrow">PREVENTIVO</span><h2>Agregar registro sin pendiente previo</h2><p className="section-copy">Sólo se muestran registros pertenecientes al Área y Operadora seleccionadas.</p></div></div>
-      <label className="field"><span>Buscar registro</span><input value={assetSearch} onChange={(event) => setAssetSearch(event.target.value)} placeholder="Código o nombre" /></label>
-      <div className="form-grid"><label className="field"><span>Registro preventivo</span><SearchableSelect value={newAssetId} onChange={(event) => setNewAssetId(event.target.value)} required><option value="">Seleccionar…</option>{candidateAssets.map((asset) => <option key={asset.id} value={asset.id}>{asset.code} · {asset.name} · {asset.type.name}</option>)}</SearchableSelect></label></div>
-      <div className="form-actions"><button className="button primary" disabled={busy || !newAssetId}><Icon name="plus" />Agregar preventivo</button></div>
-    </form>}
-
-    {visit && <div className="table-panel inspection-assets"><div className="table-summary"><strong>{visit.assets.length} registro{visit.assets.length === 1 ? '' : 's'} incluidos</strong><span>{visit.checklist.excludedAssets} excluidos con trazabilidad.</span></div>{visit.planningAssets.length === 0 ? <EmptyState title="Sin registros" text="Generá el checklist o agregá al menos un registro preventivo." /> : <div className="table-scroll"><table><thead><tr><th>Registro</th><th>Origen</th><th>Estado</th><th>Motivo</th><th /></tr></thead><tbody>{visit.planningAssets.map((asset) => <tr key={asset.id}><td><Link className="history-asset-link" to={`/inventarios/${asset.id}`}><strong>{asset.name}</strong><small>{asset.code} · {asset.typeName}</small></Link></td><td>{sourceLabel(asset.planningSource)}</td><td><span className={`status-badge ${asset.included ? 'success' : 'muted'}`}>{asset.included ? 'Incluido' : 'Excluido'}</span></td><td>{asset.exclusionReason ? <><strong>{asset.exclusionReason}</strong><small>{asset.excludedBy ? `Por ${personName(asset.excludedBy)}` : ''}{asset.excludedAt ? ` · ${formatDate(asset.excludedAt)}` : ''}</small></> : '—'}</td><td className="action-cell">{canManage && planningEditable && (asset.included ? <button type="button" className="button danger-outline compact" onClick={() => void excludeAsset(asset.id)} disabled={busy}>Excluir</button> : <button type="button" className="button secondary compact" onClick={() => void reincludeAsset(asset.id)} disabled={busy}>Reincorporar</button>)}</td></tr>)}</tbody></table></div>}</div>}
-
-    {visit && canAssign && planningEditable && <form className="panel inspection-team-panel" onSubmit={saveTeam}>
-      <div className="panel-heading"><div><span className="eyebrow">EQUIPO</span><h2>Responsable e integrantes</h2></div><span className="count-pill">{memberIds.size}</span></div>
-      <label className="field"><span>Inspector responsable</span><SearchableSelect value={leadInspectorId} onChange={(event) => chooseLead(event.target.value)}><option value="">Seleccionar…</option>{assignees.map((person) => <option key={person.id} value={person.id}>{personName(person)} · {person.username}</option>)}</SearchableSelect></label>
-      <div className="inspection-team-grid">{assignees.map((person) => <label className={`inspection-member ${memberIds.has(person.id) ? 'selected' : ''}`} key={person.id}><input type="checkbox" checked={memberIds.has(person.id)} disabled={person.id === leadInspectorId} onChange={(event) => setMemberIds((current) => { const next = new Set(current); event.target.checked ? next.add(person.id) : next.delete(person.id); return next; })} /><span><strong>{personName(person)}</strong><small>{person.username}{person.id === leadInspectorId ? ' · Responsable' : ''}</small></span></label>)}</div>
-      <div className="form-actions"><button className="button primary" disabled={busy}><Icon name="check" />Guardar equipo</button></div>
-    </form>}
-
-    {visit && !canAssign && <article className="panel"><div className="panel-heading"><div><span className="eyebrow">EQUIPO</span><h2>{visit.leadInspector ? personName(visit.leadInspector) : 'Sin responsable'}</h2></div><span className="count-pill">{visit.team.length}</span></div><div className="inspection-team-grid">{visit.team.map((member) => <div className="inspection-member selected" key={member.id}><span><strong>{personName(member)}</strong><small>{member.username}{member.id === visit.leadInspector?.id ? ' · Responsable' : ''}</small></span></div>)}</div></article>}
-
-    {visit && <InspectionActsPanel visit={visit} />}
-
-    {visit && <div className="survey-status-actions panel"><div><strong>Flujo de la inspección</strong><p>Oficina planifica y asigna. El inspector responsable inicia la inspección desde la APK; toda la ejecución de campo sigue siendo exclusiva del dispositivo móvil.</p></div><div>{canManage && visit.status === 'DRAFT' && <button type="button" className="button secondary" onClick={() => void changeStatus('PLANNED')} disabled={busy}>Confirmar planificación</button>}{canManage && visit.status === 'PLANNED' && <button type="button" className="button secondary" onClick={() => void changeStatus('DRAFT')} disabled={busy}>Volver a borrador</button>}{canManage && ['DRAFT', 'PLANNED'].includes(visit.status) && <button type="button" className="button danger-outline" onClick={() => void changeStatus('CANCELLED')} disabled={busy}>Cancelar planificación</button>}</div></div>}
-
-    {visit?.status === 'PLANNED' && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Planificación lista.</strong> El inspector asignado debe iniciar la inspección desde la APK. El dashboard no dispone de acción de inicio.</p></div>}
-    {visit?.status === 'IN_PROGRESS' && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Inspección iniciada {formatDate(visit.actualStartedAt)}.</strong> Las actas, hallazgos, evidencias y el cierre de la inspección se registran desde la APK; aquí se consultan.</p></div>}
-    {visit?.status === 'CANCELLED' && <Alert>Cancelada: {visit.cancellationReason}</Alert>}
-  </section>;
-}

From b69b773094c01fb0c43d7f861b5462902ed8aaca Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:11:24 -0300
Subject: [PATCH 109/224] F4: present locked and sealed Act states

---
 .../inspections/inspectionActPresentation.ts  | 34 +++++++++++--------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/web-v2/src/features/inspections/inspectionActPresentation.ts b/web-v2/src/features/inspections/inspectionActPresentation.ts
index b86d1fe..21d9f5a 100644
--- a/web-v2/src/features/inspections/inspectionActPresentation.ts
+++ b/web-v2/src/features/inspections/inspectionActPresentation.ts
@@ -1,33 +1,37 @@
-import type { InspectionActStatus, InspectionActVersionEvent } from '../../lib/api';
+import type { InspectionActVersionEvent } from '../../lib/api';
 
-const statusLabels: Record<InspectionActStatus, string> = {
+const statusLabels: Record<string, string> = {
   DRAFT: 'Borrador',
-  READY: 'Lista para cerrar',
-  CLOSED: 'Cerrada',
+  LOCKED: 'Bloqueada · esperando manifestación',
+  SEALED: 'Sellada',
+  READY: 'Lista para cerrar · legado',
+  CLOSED: 'Cerrada · legado',
   CANCELLED: 'Cancelada',
-  RECTIFIED: 'Rectificada',
+  RECTIFIED: 'Rectificada · legado',
 };
 
-const eventLabels: Record<InspectionActVersionEvent, string> = {
+const eventLabels: Record<string, string> = {
   CREATED: 'Creación',
   UPDATED: 'Actualización',
-  READY: 'Preparación para firmas',
+  LOCKED: 'Bloqueo para firmas',
+  SEALED: 'Sellado definitivo',
+  READY: 'Preparación para firmas · legado',
   REOPENED: 'Vuelta a borrador',
-  CLOSED: 'Cierre y sellado',
+  CLOSED: 'Cierre · legado',
   CANCELLED: 'Cancelación',
 };
 
-export function inspectionActStatusLabel(value: InspectionActStatus): string {
-  return statusLabels[value];
+export function inspectionActStatusLabel(value: string): string {
+  return statusLabels[value] ?? value;
 }
 
-export function inspectionActStatusClass(value: InspectionActStatus): string {
-  if (value === 'CLOSED') return 'active';
-  if (value === 'READY' || value === 'RECTIFIED') return 'observed';
+export function inspectionActStatusClass(value: string): string {
+  if (value === 'SEALED' || value === 'CLOSED') return 'active';
+  if (value === 'LOCKED' || value === 'READY' || value === 'RECTIFIED') return 'observed';
   if (value === 'CANCELLED') return 'inactive';
   return 'pending';
 }
 
-export function inspectionActVersionEventLabel(value: InspectionActVersionEvent): string {
-  return eventLabels[value];
+export function inspectionActVersionEventLabel(value: InspectionActVersionEvent | string): string {
+  return eventLabels[value] ?? value;
 }

From 8d962e783d9c0904f439b6cc28a1170674f53257 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:13:24 -0300
Subject: [PATCH 110/224] F4: add Superadmin SMTP settings client

---
 web-v2/src/lib/smtpSettingsApi.ts | 46 +++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 web-v2/src/lib/smtpSettingsApi.ts

diff --git a/web-v2/src/lib/smtpSettingsApi.ts b/web-v2/src/lib/smtpSettingsApi.ts
new file mode 100644
index 0000000..5913879
--- /dev/null
+++ b/web-v2/src/lib/smtpSettingsApi.ts
@@ -0,0 +1,46 @@
+import { apiRequest } from './api';
+
+export type SmtpSecurityMode = 'NONE' | 'STARTTLS' | 'TLS';
+
+export interface PublicSmtpSettings {
+  source: 'DATABASE' | 'ENVIRONMENT' | 'NONE';
+  id?: string;
+  host?: string;
+  port?: number;
+  securityMode?: SmtpSecurityMode;
+  username?: string | null;
+  hasPassword?: boolean;
+  fromName?: string | null;
+  fromEmail?: string;
+  replyTo?: string | null;
+  enabled: boolean;
+  updatedAt?: string;
+}
+
+export function getSmtpSettings() {
+  return apiRequest<PublicSmtpSettings>('/document-delivery/smtp');
+}
+
+export function saveSmtpSettings(input: {
+  host: string;
+  port: number;
+  securityMode: SmtpSecurityMode;
+  username?: string | null;
+  password?: string | null;
+  fromName: string;
+  fromEmail: string;
+  replyTo?: string | null;
+  enabled: boolean;
+}) {
+  return apiRequest<PublicSmtpSettings>('/document-delivery/smtp', {
+    method: 'PUT',
+    body: JSON.stringify(input),
+  });
+}
+
+export function testSmtpSettings(email: string) {
+  return apiRequest<{ ok: boolean; recipient: string; messageId: string }>('/document-delivery/smtp/test', {
+    method: 'POST',
+    body: JSON.stringify({ email }),
+  });
+}

From 2319d066856a0038c3ea90f81235a24a0e813043 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:13:41 -0300
Subject: [PATCH 111/224] F4: add document delivery client without Director

---
 web-v2/src/lib/documentDeliveryF4Api.ts | 51 +++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 web-v2/src/lib/documentDeliveryF4Api.ts

diff --git a/web-v2/src/lib/documentDeliveryF4Api.ts b/web-v2/src/lib/documentDeliveryF4Api.ts
new file mode 100644
index 0000000..aee3f70
--- /dev/null
+++ b/web-v2/src/lib/documentDeliveryF4Api.ts
@@ -0,0 +1,51 @@
+import { apiRequest } from './api';
+
+export interface DocumentDeliverySettingsF4 {
+  officeEmail: string | null;
+  smtpConfigured: boolean;
+  mailFrom: string | null;
+  updatedAt?: string;
+}
+
+export interface DocumentDeliveryItemF4 {
+  id: string;
+  actId: string;
+  reportId: string | null;
+  documentKind: 'ACT_PDF' | 'REPORT_WORD';
+  recipientKind: 'COMPANY' | 'OFFICE' | 'INSPECTOR';
+  recipientAssetId: string | null;
+  recipientUserId: string | null;
+  recipientEmail: string | null;
+  recipientAssetName?: string | null;
+  recipientUserName?: string | null;
+  status: 'PENDING' | 'WAITING_RECIPIENT' | 'WAITING_TRANSPORT' | 'WAITING_ARTIFACT' | 'SENT' | 'FAILED';
+  attempts: number;
+  lastAttemptAt?: string | null;
+  sentAt?: string | null;
+  lastError?: string | null;
+  actCode: string;
+  reportCode: string | null;
+}
+
+export function getDocumentDeliverySettingsF4() {
+  return apiRequest<DocumentDeliverySettingsF4>('/document-delivery/settings');
+}
+
+export function updateDocumentDeliverySettingsF4(officeEmail: string | null) {
+  return apiRequest<DocumentDeliverySettingsF4>('/document-delivery/settings', {
+    method: 'PATCH',
+    body: JSON.stringify({ officeEmail }),
+  });
+}
+
+export function listDocumentDeliveriesF4() {
+  return apiRequest<{ data: DocumentDeliveryItemF4[] }>('/document-delivery/outbox');
+}
+
+export function retryDocumentDeliveryF4(id: string) {
+  return apiRequest<DocumentDeliveryItemF4>(`/document-delivery/outbox/${id}/retry`, { method: 'POST' });
+}
+
+export function retryPendingDocumentDeliveriesF4() {
+  return apiRequest<{ processed: number }>('/document-delivery/outbox/retry-pending', { method: 'POST' });
+}

From 830addb7b5690440a586cf40743f22a040e7d434 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:14:15 -0300
Subject: [PATCH 112/224] F4: make SMTP configurable from Superadmin and remove
 Director

---
 web-v2/src/pages/DocumentDeliveryPage.tsx | 224 +++++++++++++---------
 1 file changed, 136 insertions(+), 88 deletions(-)

diff --git a/web-v2/src/pages/DocumentDeliveryPage.tsx b/web-v2/src/pages/DocumentDeliveryPage.tsx
index baeaa3c..9c26fe9 100644
--- a/web-v2/src/pages/DocumentDeliveryPage.tsx
+++ b/web-v2/src/pages/DocumentDeliveryPage.tsx
@@ -1,17 +1,25 @@
-import { FormEvent, useEffect, useState } from 'react';
+import { useEffect, useState } from 'react';
+import type { FormEvent } from 'react';
 import { useAuth } from '../auth/AuthContext';
 import { Alert, LoadingBlock, errorMessage } from '../components/Feedback';
 import { Icon } from '../components/Icon';
+import { SearchableSelect } from '../components/SearchableSelect';
 import {
-  getDocumentDeliverySettings,
-  listDocumentDeliveries,
-  retryDocumentDelivery,
-  retryPendingDocumentDeliveries,
-  updateDocumentDeliverySettings,
-} from '../lib/api';
-import type { DocumentDeliveryItem, DocumentDeliverySettings } from '../lib/api';
+  getDocumentDeliverySettingsF4,
+  listDocumentDeliveriesF4,
+  retryDocumentDeliveryF4,
+  retryPendingDocumentDeliveriesF4,
+  updateDocumentDeliverySettingsF4,
+} from '../lib/documentDeliveryF4Api';
+import type { DocumentDeliveryItemF4, DocumentDeliverySettingsF4 } from '../lib/documentDeliveryF4Api';
+import {
+  getSmtpSettings,
+  saveSmtpSettings,
+  testSmtpSettings,
+} from '../lib/smtpSettingsApi';
+import type { PublicSmtpSettings, SmtpSecurityMode } from '../lib/smtpSettingsApi';
 
-const statusLabel: Record<DocumentDeliveryItem['status'], string> = {
+const statusLabel: Record<DocumentDeliveryItemF4['status'], string> = {
   PENDING: 'Pendiente',
   WAITING_RECIPIENT: 'Falta destinatario',
   WAITING_TRANSPORT: 'SMTP sin configurar',
@@ -20,125 +28,165 @@ const statusLabel: Record<DocumentDeliveryItem['status'], string> = {
   FAILED: 'Error',
 };
 
-type DeliveryWithInspector = DocumentDeliveryItem & {
-  recipientUserId?: string | null;
-  recipientUserName?: string | null;
-};
-
-function recipientLabel(item: DeliveryWithInspector): string {
+function recipientLabel(item: DocumentDeliveryItemF4): string {
   if (item.recipientAssetName) return item.recipientAssetName;
   if (item.recipientUserName) return item.recipientUserName;
-  const kind = String(item.recipientKind);
-  if (kind === 'COMPANY') return 'Empresa sin identificar';
-  if (kind === 'OFFICE') return 'Oficina';
-  if (kind === 'INSPECTOR') return 'Inspector responsable';
-  return 'Director';
+  if (item.recipientKind === 'COMPANY') return 'Empresa sin identificar';
+  if (item.recipientKind === 'OFFICE') return 'Oficina';
+  return 'Inspector responsable';
+}
+
+function defaultPort(mode: SmtpSecurityMode): number {
+  return mode === 'TLS' ? 465 : mode === 'STARTTLS' ? 587 : 25;
 }
 
 export function DocumentDeliveryPage() {
   const { hasPermission } = useAuth();
   const canManage = hasPermission('document_delivery.manage');
-  const [settings, setSettings] = useState<DocumentDeliverySettings | null>(null);
-  const [items, setItems] = useState<DocumentDeliveryItem[]>([]);
+  const [settings, setSettings] = useState<DocumentDeliverySettingsF4 | null>(null);
+  const [smtp, setSmtp] = useState<PublicSmtpSettings | null>(null);
+  const [items, setItems] = useState<DocumentDeliveryItemF4[]>([]);
   const [officeEmail, setOfficeEmail] = useState('');
-  const [directorEmail, setDirectorEmail] = useState('');
+  const [host, setHost] = useState('');
+  const [port, setPort] = useState('587');
+  const [securityMode, setSecurityMode] = useState<SmtpSecurityMode>('STARTTLS');
+  const [username, setUsername] = useState('');
+  const [password, setPassword] = useState('');
+  const [fromName, setFromName] = useState('DH Inspección');
+  const [fromEmail, setFromEmail] = useState('');
+  const [replyTo, setReplyTo] = useState('');
+  const [smtpEnabled, setSmtpEnabled] = useState(true);
+  const [testEmail, setTestEmail] = useState('');
   const [loading, setLoading] = useState(true);
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState('');
   const [success, setSuccess] = useState('');
 
+  const applySmtp = (value: PublicSmtpSettings) => {
+    setSmtp(value);
+    setHost(value.host ?? '');
+    setPort(String(value.port ?? defaultPort(value.securityMode ?? 'STARTTLS')));
+    setSecurityMode(value.securityMode ?? 'STARTTLS');
+    setUsername(value.username ?? '');
+    setPassword('');
+    setFromName(value.fromName ?? 'DH Inspección');
+    setFromEmail(value.fromEmail ?? '');
+    setReplyTo(value.replyTo ?? '');
+    setSmtpEnabled(value.enabled);
+  };
+
   const load = async () => {
-    const [currentSettings, outbox] = await Promise.all([
-      getDocumentDeliverySettings(),
-      listDocumentDeliveries(),
+    const [currentSettings, outbox, smtpSettings] = await Promise.all([
+      getDocumentDeliverySettingsF4(),
+      listDocumentDeliveriesF4(),
+      canManage ? getSmtpSettings() : Promise.resolve(null),
     ]);
     setSettings(currentSettings);
     setOfficeEmail(currentSettings.officeEmail ?? '');
-    setDirectorEmail(currentSettings.directorEmail ?? '');
     setItems(outbox.data);
+    if (smtpSettings) applySmtp(smtpSettings);
   };
 
   useEffect(() => {
     load().catch((requestError) => setError(errorMessage(requestError))).finally(() => setLoading(false));
-  }, []);
+  }, [canManage]);
 
-  const save = async (event: FormEvent) => {
+  const saveOffice = async (event: FormEvent) => {
     event.preventDefault();
-    setSaving(true);
-    setError('');
-    setSuccess('');
+    setSaving(true); setError(''); setSuccess('');
     try {
-      const currentSettings = await updateDocumentDeliverySettings({
-        officeEmail: officeEmail || null,
-        directorEmail: directorEmail || null,
-      });
-      setSettings(currentSettings);
-      setSuccess('Destinatarios institucionales actualizados');
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setSaving(false);
-    }
+      const updated = await updateDocumentDeliverySettingsF4(officeEmail.trim() || null);
+      setSettings(updated);
+      setSuccess('Destinatario institucional de oficina actualizado.');
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setSaving(false); }
+  };
+
+  const saveSmtp = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!host.trim() || !fromName.trim() || !fromEmail.trim()) return;
+    setSaving(true); setError(''); setSuccess('');
+    try {
+      const input: Parameters<typeof saveSmtpSettings>[0] = {
+        host: host.trim(),
+        port: Number(port),
+        securityMode,
+        username: username.trim() || null,
+        fromName: fromName.trim(),
+        fromEmail: fromEmail.trim(),
+        replyTo: replyTo.trim() || null,
+        enabled: smtpEnabled,
+      };
+      if (password) input.password = password;
+      const updated = await saveSmtpSettings(input);
+      applySmtp(updated);
+      setSuccess('Configuración SMTP guardada. La contraseña no se devuelve ni se muestra en pantalla.');
+      const refreshed = await getDocumentDeliverySettingsF4();
+      setSettings(refreshed);
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setSaving(false); }
+  };
+
+  const sendTest = async (event: FormEvent) => {
+    event.preventDefault();
+    if (!testEmail.trim()) return;
+    setSaving(true); setError(''); setSuccess('');
+    try {
+      const result = await testSmtpSettings(testEmail.trim());
+      setSuccess(`Prueba SMTP enviada a ${result.recipient}.`);
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setSaving(false); }
   };
 
   const retryAll = async () => {
-    setSaving(true);
-    setError('');
-    setSuccess('');
+    setSaving(true); setError(''); setSuccess('');
     try {
-      const result = await retryPendingDocumentDeliveries();
+      const result = await retryPendingDocumentDeliveriesF4();
       await load();
       setSuccess(`Se procesaron ${result.processed} entrega/s pendientes.`);
-    } catch (requestError) {
-      setError(errorMessage(requestError));
-    } finally {
-      setSaving(false);
-    }
+    } catch (requestError) { setError(errorMessage(requestError)); }
+    finally { setSaving(false); }
   };
 
   if (loading) return <LoadingBlock label="Cargando entrega documental…" />;
 
   return <section className="narrow-section">
-    <div className="page-heading">
-      <div>
-        <span className="eyebrow">DOCUMENTOS</span>
-        <h1>Entrega documental</h1>
-        <p>Configurá los destinatarios institucionales y controlá el envío automático de Actas e Informes.</p>
-      </div>
-      {canManage && <button className="button secondary" onClick={retryAll} disabled={saving}><Icon name="history" />Reintentar pendientes</button>}
-    </div>
-    {error && <Alert>{error}</Alert>}
-    {success && <Alert type="success">{success}</Alert>}
+    <div className="page-heading"><div><span className="eyebrow">SUPERADMIN · CORREO</span><h1>Entrega documental</h1><p>Configuración institucional de SMTP, destinatarios y trazabilidad de los envíos automáticos.</p></div>{canManage && <button className="button secondary" onClick={retryAll} disabled={saving}><Icon name="history" />Reintentar pendientes</button>}</div>
+    {error && <Alert>{error}</Alert>}{success && <Alert type="success">{success}</Alert>}
 
-    <form className="panel form-panel" onSubmit={save}>
+    <form className="panel form-panel" onSubmit={saveOffice}>
       <div className="form-section">
-        <div>
-          <h2>Destinatarios institucionales</h2>
-          <p className="section-copy">El email de cada empresa se configura dentro de su ficha de Inventario. El Inspector responsable usa automáticamente el email declarado en su Usuario. Las credenciales SMTP permanecen fuera de la base de datos.</p>
-        </div>
-        <div className="form-grid">
-          <label className="field"><span>Email de oficina</span><input type="email" value={officeEmail} onChange={(event) => setOfficeEmail(event.target.value)} disabled={!canManage} /></label>
-          <label className="field"><span>Email del Director de Hidrocarburos</span><input type="email" value={directorEmail} onChange={(event) => setDirectorEmail(event.target.value)} disabled={!canManage} /></label>
-        </div>
-        <div className="temporal-notice"><Icon name={settings?.smtpConfigured ? 'check' : 'alert'} /><p><strong>{settings?.smtpConfigured ? 'Servidor de correo configurado' : 'Servidor de correo pendiente'}</strong>{settings?.mailFrom ? ` · Remitente ${settings.mailFrom}` : ' · Falta configurar SMTP_HOST y MAIL_FROM en el servidor.'}</p></div>
-        {canManage && <div className="form-actions"><button className="button primary" disabled={saving}><Icon name="check" />{saving ? 'Guardando…' : 'Guardar destinatarios'}</button></div>}
+        <div><h2>Destinatarios institucionales</h2><p className="section-copy">La empresa usa el email de su ficha de Inventario. El Inspector usa el email de su Usuario. Acá se configura únicamente la copia institucional de oficina.</p></div>
+        <label className="field"><span>Email de oficina</span><input type="email" value={officeEmail} onChange={(event) => setOfficeEmail(event.target.value)} disabled={!canManage} /></label>
+        <div className="temporal-notice"><Icon name={settings?.smtpConfigured ? 'check' : 'alert'} /><p><strong>{settings?.smtpConfigured ? 'Salida SMTP operativa' : 'Salida SMTP pendiente'}</strong>{settings?.mailFrom ? ` · Remitente ${settings.mailFrom}` : ''}</p></div>
+        {canManage && <div className="form-actions"><button className="button primary" disabled={saving}>Guardar destinatario</button></div>}
       </div>
     </form>
 
-    <div className="panel">
-      <div className="panel-heading"><div><span className="eyebrow">TRAZABILIDAD</span><h2>Últimas entregas</h2></div><span>{items.length}</span></div>
-      {items.length === 0
-        ? <div className="inline-empty">Todavía no existen entregas documentales.</div>
-        : <div className="table-wrap"><table><thead><tr><th>Documento</th><th>Destino</th><th>Estado</th><th>Intentos</th><th></th></tr></thead><tbody>{items.map((baseItem) => {
-          const item = baseItem as DeliveryWithInspector;
-          return <tr key={item.id}>
-            <td><strong>{item.documentKind === 'ACT_PDF' ? item.actCode : item.reportCode}</strong><small className="block-muted">{item.documentKind === 'ACT_PDF' ? 'Acta PDF' : 'Informe Word'}</small></td>
-            <td>{recipientLabel(item)}<small className="block-muted">{item.recipientEmail ?? 'Sin email configurado'}</small></td>
-            <td><span className={`status-badge ${item.status === 'SENT' ? 'active' : item.status === 'FAILED' ? 'inactive' : 'pending'}`}>{statusLabel[item.status]}</span>{item.lastError && <small className="block-muted">{item.lastError}</small>}</td>
-            <td>{item.attempts}</td>
-            <td>{canManage && item.status !== 'SENT' && <button className="button text" type="button" disabled={saving} onClick={async () => { setSaving(true); try { await retryDocumentDelivery(item.id); await load(); } catch (requestError) { setError(errorMessage(requestError)); } finally { setSaving(false); } }}>Reintentar</button>}</td>
-          </tr>;
-        })}</tbody></table></div>}
-    </div>
+    {canManage && <form className="panel form-panel" onSubmit={saveSmtp}>
+      <div className="form-section">
+        <div><span className="eyebrow">SALIDA DE EMAIL</span><h2>Servidor SMTP</h2><p className="section-copy">La contraseña se cifra en el servidor con AES-256-GCM. Al volver a esta pantalla sólo se informa si existe una clave guardada; nunca se devuelve su contenido.</p></div>
+        {smtp?.source === 'ENVIRONMENT' && <Alert type="info">Actualmente se está usando la configuración del servidor. Al guardar este formulario, la configuración de base de datos administrable pasará a tener prioridad.</Alert>}
+        <div className="form-grid">
+          <label className="field"><span>Host SMTP</span><input value={host} onChange={(event) => setHost(event.target.value)} required maxLength={255} placeholder="smtp.ejemplo.com" /></label>
+          <label className="field"><span>Puerto</span><input type="number" min={1} max={65535} value={port} onChange={(event) => setPort(event.target.value)} required /></label>
+          <label className="field"><span>Seguridad</span><SearchableSelect value={securityMode} onChange={(event) => { const mode = event.target.value as SmtpSecurityMode; setSecurityMode(mode); setPort(String(defaultPort(mode))); }}><option value="STARTTLS">STARTTLS · habitual 587</option><option value="TLS">TLS implícito · habitual 465</option><option value="NONE">Sin cifrado · sólo redes controladas</option></SearchableSelect></label>
+          <label className="field"><span>Usuario <em>opcional</em></span><input value={username} onChange={(event) => setUsername(event.target.value)} maxLength={255} autoComplete="username" /></label>
+          <label className="field"><span>Contraseña {smtp?.hasPassword && <em>· ya existe una guardada</em>}</span><input type="password" value={password} onChange={(event) => setPassword(event.target.value)} maxLength={1000} autoComplete="new-password" placeholder={smtp?.hasPassword ? 'Dejar vacío para conservar la actual' : 'Contraseña SMTP'} /></label>
+          <label className="field"><span>Nombre remitente</span><input value={fromName} onChange={(event) => setFromName(event.target.value)} required maxLength={200} /></label>
+          <label className="field"><span>Email remitente</span><input type="email" value={fromEmail} onChange={(event) => setFromEmail(event.target.value)} required maxLength={320} /></label>
+          <label className="field"><span>Reply-To <em>opcional</em></span><input type="email" value={replyTo} onChange={(event) => setReplyTo(event.target.value)} maxLength={320} /></label>
+        </div>
+        <label className="inspection-member selected"><input type="checkbox" checked={smtpEnabled} onChange={(event) => setSmtpEnabled(event.target.checked)} /><span><strong>Habilitar envío de correo</strong><small>Si se desactiva, las entregas quedan en espera sin perderse.</small></span></label>
+        <div className="form-actions"><button className="button primary" disabled={saving || !host.trim() || !fromName.trim() || !fromEmail.trim()}>{saving ? 'Guardando…' : 'Guardar SMTP'}</button></div>
+      </div>
+    </form>}
+
+    {canManage && <form className="panel form-panel" onSubmit={sendTest}><div className="form-section"><div><h2>Probar configuración</h2><p className="section-copy">Envía un correo real con un archivo de prueba usando exactamente la configuración activa.</p></div><div className="form-grid"><label className="field"><span>Email de prueba</span><input type="email" value={testEmail} onChange={(event) => setTestEmail(event.target.value)} required placeholder="tu@email.com" /></label></div><div className="form-actions"><button className="button secondary" disabled={saving || !testEmail.trim()}>Enviar prueba</button></div></div></form>}
+
+    <article className="panel">
+      <div className="panel-heading"><div><span className="eyebrow">TRAZABILIDAD</span><h2>Últimas entregas</h2><p className="section-copy">Actas PDF a Empresa/Oficina/Inspector e INF Word editable al Inspector responsable.</p></div><span className="count-pill">{items.length}</span></div>
+      {items.length === 0 ? <div className="inline-empty">Todavía no existen entregas documentales.</div> : <div className="table-wrap"><table><thead><tr><th>Documento</th><th>Destino</th><th>Estado</th><th>Intentos</th><th /></tr></thead><tbody>{items.map((item) => <tr key={item.id}><td><strong>{item.documentKind === 'ACT_PDF' ? item.actCode : item.reportCode}</strong><small className="block-muted">{item.documentKind === 'ACT_PDF' ? 'Acta PDF inmutable' : 'INF Word editable'}</small></td><td>{recipientLabel(item)}<small className="block-muted">{item.recipientEmail ?? 'Sin email configurado'}</small></td><td><span className={`status-badge ${item.status === 'SENT' ? 'active' : item.status === 'FAILED' ? 'inactive' : 'pending'}`}>{statusLabel[item.status]}</span>{item.lastError && <small className="block-muted">{item.lastError}</small>}</td><td>{item.attempts}</td><td>{canManage && item.status !== 'SENT' && <button className="button text" type="button" disabled={saving} onClick={async () => { setSaving(true); try { await retryDocumentDeliveryF4(item.id); await load(); } catch (requestError) { setError(errorMessage(requestError)); } finally { setSaving(false); } }}>Reintentar</button>}</td></tr>)}</tbody></table></div>}
+    </article>
   </section>;
 }

From 3e2b021943f72ca7b8e110aae9b25abcc2f1bdb8 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:15:02 -0300
Subject: [PATCH 113/224] F4: remove obsolete survey campaigns controller

---
 .../survey-campaigns.controller.ts            | 131 ------------------
 1 file changed, 131 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/survey-campaigns.controller.ts

diff --git a/api-v3/src/survey-planning/survey-campaigns.controller.ts b/api-v3/src/survey-planning/survey-campaigns.controller.ts
deleted file mode 100644
index a1a506a..0000000
--- a/api-v3/src/survey-planning/survey-campaigns.controller.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Param,
-  ParseUUIDPipe,
-  Patch,
-  Post,
-  Put,
-  Query,
-  Req,
-} from '@nestjs/common';
-import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
-import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
-import type {
-  AuthPrincipal,
-  RequestWithContext,
-} from '../common/http/request-context';
-import { AddSurveyTargetDto } from './dto/add-survey-target.dto';
-import { AssignSurveyTargetDto } from './dto/assign-survey-target.dto';
-import { ChangeSurveyCampaignStatusDto } from './dto/change-survey-campaign-status.dto';
-import { ChangeSurveyTargetStatusDto } from './dto/change-survey-target-status.dto';
-import { CreateSurveyCampaignDto } from './dto/create-survey-campaign.dto';
-import { ListSurveyCampaignsQueryDto } from './dto/list-survey-campaigns-query.dto';
-import { UpdateSurveyCampaignDto } from './dto/update-survey-campaign.dto';
-import { UpdateSurveyTargetDto } from './dto/update-survey-target.dto';
-import { SurveyPlanningService } from './survey-planning.service';
-
-@Controller('survey-campaigns')
-export class SurveyCampaignsController {
-  constructor(private readonly planning: SurveyPlanningService) {}
-
-  @Get()
-  @RequirePermissions('surveys.read')
-  list(@Query() query: ListSurveyCampaignsQueryDto) {
-    return this.planning.list(query);
-  }
-
-  @Get('assignees')
-  @RequirePermissions('surveys.assign')
-  assignees() {
-    return this.planning.listAssignees();
-  }
-
-  @Post()
-  @RequirePermissions('surveys.manage')
-  create(
-    @Body() dto: CreateSurveyCampaignDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.planning.create(dto, principal, request);
-  }
-
-  @Get(':id')
-  @RequirePermissions('surveys.read')
-  get(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
-    return this.planning.getById(id);
-  }
-
-  @Patch(':id')
-  @RequirePermissions('surveys.manage')
-  update(
-    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: UpdateSurveyCampaignDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.planning.update(id, dto, principal, request);
-  }
-
-  @Put(':id/status')
-  @RequirePermissions('surveys.manage')
-  changeStatus(
-    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: ChangeSurveyCampaignStatusDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.planning.changeCampaignStatus(id, dto, principal, request);
-  }
-
-  @Post(':id/targets')
-  @RequirePermissions('surveys.manage')
-  addTarget(
-    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: AddSurveyTargetDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.planning.addTarget(id, dto, principal, request);
-  }
-}
-
-@Controller('survey-campaign-targets')
-export class SurveyCampaignTargetsController {
-  constructor(private readonly planning: SurveyPlanningService) {}
-
-  @Patch(':id')
-  @RequirePermissions('surveys.manage')
-  update(
-    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: UpdateSurveyTargetDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.planning.updateTarget(id, dto, principal, request);
-  }
-
-  @Put(':id/assignment')
-  @RequirePermissions('surveys.assign')
-  assign(
-    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: AssignSurveyTargetDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.planning.assignTarget(id, dto, principal, request);
-  }
-
-  @Put(':id/status')
-  @RequirePermissions('surveys.execute')
-  changeStatus(
-    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
-    @Body() dto: ChangeSurveyTargetStatusDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.planning.changeTargetStatus(id, dto, principal, request);
-  }
-}

From 17e2e1902ba702b746c764c5b83f1c247d13c5a7 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:15:10 -0300
Subject: [PATCH 114/224] F4: remove obsolete survey planning module

---
 .../src/survey-planning/survey-planning.module.ts  | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/survey-planning.module.ts

diff --git a/api-v3/src/survey-planning/survey-planning.module.ts b/api-v3/src/survey-planning/survey-planning.module.ts
deleted file mode 100644
index 42a8cf6..0000000
--- a/api-v3/src/survey-planning/survey-planning.module.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { Module } from '@nestjs/common';
-import { AuditModule } from '../audit/audit.module';
-import {
-  SurveyCampaignsController,
-  SurveyCampaignTargetsController,
-} from './survey-campaigns.controller';
-import { SurveyPlanningService } from './survey-planning.service';
-
-@Module({
-  imports: [AuditModule],
-  controllers: [SurveyCampaignsController, SurveyCampaignTargetsController],
-  providers: [SurveyPlanningService],
-})
-export class SurveyPlanningModule {}

From 0bab3e5b70afb62e5f2683047343fb928eab7b0d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:15:19 -0300
Subject: [PATCH 115/224] F4: remove obsolete survey planning service

---
 .../survey-planning.service.ts                | 791 ------------------
 1 file changed, 791 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/survey-planning.service.ts

diff --git a/api-v3/src/survey-planning/survey-planning.service.ts b/api-v3/src/survey-planning/survey-planning.service.ts
deleted file mode 100644
index 7a4a111..0000000
--- a/api-v3/src/survey-planning/survey-planning.service.ts
+++ /dev/null
@@ -1,791 +0,0 @@
-import {
-  BadRequestException,
-  ConflictException,
-  ForbiddenException,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-import { DataSource, EntityManager } from 'typeorm';
-import { administrationAuditContext, isUniqueViolation } from '../administration/common/administration-audit';
-import { AuditService } from '../audit/audit.service';
-import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import {
-  AuditAction,
-  SurveyCampaign,
-  SurveyCampaignStatus,
-  SurveyCampaignTarget,
-  SurveyTargetStatus,
-} from '../database/entities';
-import type { AddSurveyTargetDto } from './dto/add-survey-target.dto';
-import type { AssignSurveyTargetDto } from './dto/assign-survey-target.dto';
-import type { ChangeSurveyCampaignStatusDto } from './dto/change-survey-campaign-status.dto';
-import type { ChangeSurveyTargetStatusDto } from './dto/change-survey-target-status.dto';
-import type { CreateSurveyCampaignDto } from './dto/create-survey-campaign.dto';
-import type { ListSurveyCampaignsQueryDto } from './dto/list-survey-campaigns-query.dto';
-import type { UpdateSurveyCampaignDto } from './dto/update-survey-campaign.dto';
-import type { UpdateSurveyTargetDto } from './dto/update-survey-target.dto';
-
-export interface PersonSummary {
-  id: string;
-  username: string;
-  firstName: string;
-  lastName: string;
-}
-
-interface AssetSummary {
-  id: string;
-  code: string;
-  name: string;
-}
-
-export interface SurveyCampaignListItem {
-  id: string;
-  code: string;
-  name: string;
-  description: string | null;
-  status: SurveyCampaignStatus;
-  plannedStartAt: Date | null;
-  plannedEndAt: Date | null;
-  scopeAsset: AssetSummary | null;
-  coordinator: PersonSummary | null;
-  targetCount: number;
-  pendingCount: number;
-  inProgressCount: number;
-  submittedCount: number;
-  completedCount: number;
-  skippedCount: number;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface SurveyTargetView {
-  id: string;
-  campaignId: string;
-  asset: AssetSummary & { typeName: string };
-  assignedUser: PersonSummary | null;
-  status: SurveyTargetStatus;
-  dueAt: Date | null;
-  instructions: string | null;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface SurveyCampaignView extends SurveyCampaignListItem {
-  targets: SurveyTargetView[];
-}
-
-const campaignTransitions: Record<SurveyCampaignStatus, SurveyCampaignStatus[]> = {
-  [SurveyCampaignStatus.DRAFT]: [SurveyCampaignStatus.PLANNED, SurveyCampaignStatus.CANCELLED],
-  [SurveyCampaignStatus.PLANNED]: [
-    SurveyCampaignStatus.DRAFT,
-    SurveyCampaignStatus.IN_PROGRESS,
-    SurveyCampaignStatus.CANCELLED,
-  ],
-  [SurveyCampaignStatus.IN_PROGRESS]: [
-    SurveyCampaignStatus.COMPLETED,
-    SurveyCampaignStatus.CANCELLED,
-  ],
-  [SurveyCampaignStatus.COMPLETED]: [],
-  [SurveyCampaignStatus.CANCELLED]: [],
-};
-
-const targetTransitions: Record<SurveyTargetStatus, SurveyTargetStatus[]> = {
-  [SurveyTargetStatus.PENDING]: [SurveyTargetStatus.IN_PROGRESS, SurveyTargetStatus.SKIPPED],
-  [SurveyTargetStatus.IN_PROGRESS]: [
-    SurveyTargetStatus.PENDING,
-    SurveyTargetStatus.SKIPPED,
-  ],
-  [SurveyTargetStatus.SUBMITTED]: [],
-  [SurveyTargetStatus.COMPLETED]: [],
-  [SurveyTargetStatus.SKIPPED]: [],
-};
-
-function campaignNotFound(): NotFoundException {
-  return new NotFoundException({
-    code: 'SURVEY_CAMPAIGN_NOT_FOUND',
-    message: 'Campaña de relevamiento no encontrada',
-  });
-}
-
-function targetNotFound(): NotFoundException {
-  return new NotFoundException({
-    code: 'SURVEY_TARGET_NOT_FOUND',
-    message: 'Objetivo de relevamiento no encontrado',
-  });
-}
-
-function dateValue(value: string | null | undefined): Date | null {
-  return value ? new Date(value) : null;
-}
-
-@Injectable()
-export class SurveyPlanningService {
-  constructor(
-    private readonly dataSource: DataSource,
-    private readonly audit: AuditService,
-  ) {}
-
-  async list(query: ListSurveyCampaignsQueryDto) {
-    const conditions: string[] = [];
-    const parameters: unknown[] = [];
-    const addParameter = (value: unknown) => {
-      parameters.push(value);
-      return `$${parameters.length}`;
-    };
-
-    if (query.search?.trim()) {
-      const search = addParameter(`%${query.search.trim()}%`);
-      conditions.push(`(campaign.code ILIKE ${search} OR campaign.name ILIKE ${search})`);
-    }
-    if (query.status) conditions.push(`campaign.status = ${addParameter(query.status)}`);
-    if (query.coordinatorUserId) {
-      conditions.push(`campaign.coordinator_user_id = ${addParameter(query.coordinatorUserId)}`);
-    }
-
-    const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
-    const [countRow] = (await this.dataSource.query(
-      `SELECT COUNT(*)::integer AS total FROM survey_campaigns campaign ${where}`,
-      parameters,
-    )) as Array<{ total: number }>;
-    const total = Number(countRow?.total ?? 0);
-    const offset = (query.page - 1) * query.pageSize;
-    const limitParameter = addParameter(query.pageSize);
-    const offsetParameter = addParameter(offset);
-    const data = (await this.dataSource.query(
-      `${this.campaignSelect(where)}
-       ORDER BY campaign.updated_at DESC, campaign.code ASC
-       LIMIT ${limitParameter} OFFSET ${offsetParameter}`,
-      parameters,
-    )) as SurveyCampaignListItem[];
-
-    return {
-      data,
-      meta: {
-        page: query.page,
-        pageSize: query.pageSize,
-        total,
-        totalPages: total === 0 ? 0 : Math.ceil(total / query.pageSize),
-      },
-    };
-  }
-
-  async listAssignees(): Promise<{ data: PersonSummary[] }> {
-    const data = (await this.dataSource.query(`
-      SELECT DISTINCT
-        user_account.id,
-        user_account.username,
-        user_account.first_name AS "firstName",
-        user_account.last_name AS "lastName"
-      FROM users user_account
-      INNER JOIN user_roles user_role ON user_role.user_id = user_account.id
-      INNER JOIN role_permissions role_permission ON role_permission.role_id = user_role.role_id
-      INNER JOIN permissions permission ON permission.id = role_permission.permission_id
-      WHERE user_account.status = 'ACTIVE'
-        AND permission.code = 'surveys.execute'
-      ORDER BY user_account.last_name, user_account.first_name, user_account.username
-    `)) as PersonSummary[];
-    return { data };
-  }
-
-  async getById(id: string): Promise<SurveyCampaignView> {
-    return this.dataSource.transaction((manager) => this.loadCampaignView(manager, id));
-  }
-
-  async create(
-    dto: CreateSurveyCampaignDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyCampaignView> {
-    try {
-      return await this.dataSource.transaction(async (manager) => {
-        await this.validateDates(dto.plannedStartAt ?? null, dto.plannedEndAt ?? null);
-        await this.requireAsset(manager, dto.scopeAssetId ?? null);
-        await this.requireActiveUser(manager, dto.coordinatorUserId ?? null);
-        const campaign = manager.getRepository(SurveyCampaign).create({
-          code: dto.code,
-          name: dto.name,
-          description: dto.description ?? null,
-          status: SurveyCampaignStatus.DRAFT,
-          plannedStartAt: dateValue(dto.plannedStartAt),
-          plannedEndAt: dateValue(dto.plannedEndAt),
-          scopeAssetId: dto.scopeAssetId ?? null,
-          coordinatorUserId: dto.coordinatorUserId ?? null,
-          createdBy: principal.userId,
-          updatedBy: principal.userId,
-        });
-        await manager.getRepository(SurveyCampaign).save(campaign);
-        const created = await this.loadCampaignView(manager, campaign.id);
-        await this.audit.record({
-          ...administrationAuditContext(principal, request),
-          action: AuditAction.SURVEY_CAMPAIGN_CREATED,
-          entityType: 'survey_campaign',
-          entityId: campaign.id,
-          afterData: this.auditCampaign(created),
-        }, manager);
-        return created;
-      });
-    } catch (error) {
-      if (isUniqueViolation(error)) throw this.campaignConflict();
-      throw error;
-    }
-  }
-
-  async update(
-    id: string,
-    dto: UpdateSurveyCampaignDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyCampaignView> {
-    if (Object.keys(dto).length === 0) {
-      throw new BadRequestException({ code: 'NO_CHANGES', message: 'No se recibieron cambios' });
-    }
-    try {
-      return await this.dataSource.transaction(async (manager) => {
-        const campaign = await this.lockCampaign(manager, id);
-        this.assertCampaignEditable(campaign);
-        const before = await this.loadCampaignView(manager, id);
-        const nextStart = dto.plannedStartAt === undefined
-          ? campaign.plannedStartAt
-          : dateValue(dto.plannedStartAt);
-        const nextEnd = dto.plannedEndAt === undefined
-          ? campaign.plannedEndAt
-          : dateValue(dto.plannedEndAt);
-        await this.validateDates(nextStart, nextEnd);
-        if (dto.scopeAssetId !== undefined) {
-          await this.requireAsset(manager, dto.scopeAssetId);
-          await this.assertCampaignTargetsInScope(manager, id, dto.scopeAssetId);
-        }
-        if (dto.coordinatorUserId !== undefined) {
-          await this.requireActiveUser(manager, dto.coordinatorUserId);
-        }
-
-        if (dto.code !== undefined) campaign.code = dto.code;
-        if (dto.name !== undefined) campaign.name = dto.name;
-        if (dto.description !== undefined) campaign.description = dto.description;
-        if (dto.plannedStartAt !== undefined) campaign.plannedStartAt = nextStart;
-        if (dto.plannedEndAt !== undefined) campaign.plannedEndAt = nextEnd;
-        if (dto.scopeAssetId !== undefined) campaign.scopeAssetId = dto.scopeAssetId;
-        if (dto.coordinatorUserId !== undefined) {
-          campaign.coordinatorUserId = dto.coordinatorUserId;
-        }
-        campaign.updatedBy = principal.userId;
-        await manager.getRepository(SurveyCampaign).save(campaign);
-        const updated = await this.loadCampaignView(manager, id);
-        await this.audit.record({
-          ...administrationAuditContext(principal, request),
-          action: AuditAction.SURVEY_CAMPAIGN_UPDATED,
-          entityType: 'survey_campaign',
-          entityId: id,
-          beforeData: this.auditCampaign(before),
-          afterData: this.auditCampaign(updated),
-        }, manager);
-        return updated;
-      });
-    } catch (error) {
-      if (isUniqueViolation(error)) throw this.campaignConflict();
-      throw error;
-    }
-  }
-
-  async changeCampaignStatus(
-    id: string,
-    dto: ChangeSurveyCampaignStatusDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyCampaignView> {
-    return this.dataSource.transaction(async (manager) => {
-      const campaign = await this.lockCampaign(manager, id);
-      if (campaign.status === dto.status) return this.loadCampaignView(manager, id);
-      if (!campaignTransitions[campaign.status].includes(dto.status)) {
-        throw new ConflictException({
-          code: 'SURVEY_CAMPAIGN_INVALID_TRANSITION',
-          message: `No se puede pasar la campaña de ${campaign.status} a ${dto.status}`,
-        });
-      }
-      const [counts] = (await manager.query(`
-        SELECT
-          COUNT(*)::integer AS total,
-          COUNT(*) FILTER (WHERE status IN ('PENDING', 'IN_PROGRESS', 'SUBMITTED'))::integer AS outstanding
-        FROM survey_campaign_targets WHERE campaign_id = $1
-      `, [id])) as Array<{ total: number; outstanding: number }>;
-      if (dto.status === SurveyCampaignStatus.IN_PROGRESS && Number(counts?.total ?? 0) === 0) {
-        throw new ConflictException({
-          code: 'SURVEY_CAMPAIGN_EMPTY',
-          message: 'Agregá al menos un activo antes de iniciar la campaña',
-        });
-      }
-      if (
-        dto.status === SurveyCampaignStatus.COMPLETED &&
-        Number(counts?.outstanding ?? 0) > 0
-      ) {
-        throw new ConflictException({
-          code: 'SURVEY_CAMPAIGN_HAS_OPEN_TARGETS',
-          message: 'Todos los objetivos deben estar completados u omitidos',
-        });
-      }
-      const beforeStatus = campaign.status;
-      campaign.status = dto.status;
-      campaign.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaign).save(campaign);
-      const updated = await this.loadCampaignView(manager, id);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.SURVEY_CAMPAIGN_STATUS_CHANGED,
-        entityType: 'survey_campaign',
-        entityId: id,
-        beforeData: { status: beforeStatus },
-        afterData: { status: dto.status },
-      }, manager);
-      return updated;
-    });
-  }
-
-  async addTarget(
-    campaignId: string,
-    dto: AddSurveyTargetDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyCampaignView> {
-    try {
-      return await this.dataSource.transaction(async (manager) => {
-        const campaign = await this.lockCampaign(manager, campaignId);
-        this.assertCampaignEditable(campaign);
-        await this.requireAsset(manager, dto.assetId);
-        await this.assertAssetInScope(manager, dto.assetId, campaign.scopeAssetId);
-        await this.requireAssignee(manager, dto.assignedUserId ?? null);
-        const target = manager.getRepository(SurveyCampaignTarget).create({
-          campaignId,
-          assetId: dto.assetId,
-          assignedUserId: dto.assignedUserId ?? null,
-          status: SurveyTargetStatus.PENDING,
-          dueAt: dateValue(dto.dueAt),
-          instructions: dto.instructions ?? null,
-          createdBy: principal.userId,
-          updatedBy: principal.userId,
-        });
-        await manager.getRepository(SurveyCampaignTarget).save(target);
-        campaign.updatedBy = principal.userId;
-        await manager.getRepository(SurveyCampaign).save(campaign);
-        const targetView = await this.loadTargetView(manager, target.id);
-        await this.audit.record({
-          ...administrationAuditContext(principal, request),
-          action: AuditAction.SURVEY_TARGET_ADDED,
-          entityType: 'survey_campaign_target',
-          entityId: target.id,
-          afterData: targetView as unknown as Record<string, unknown>,
-          metadata: { campaignId },
-        }, manager);
-        return this.loadCampaignView(manager, campaignId);
-      });
-    } catch (error) {
-      if (isUniqueViolation(error)) {
-        throw new ConflictException({
-          code: 'SURVEY_TARGET_ALREADY_EXISTS',
-          message: 'El activo ya forma parte de esta campaña',
-        });
-      }
-      throw error;
-    }
-  }
-
-  async updateTarget(
-    id: string,
-    dto: UpdateSurveyTargetDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyCampaignView> {
-    if (Object.keys(dto).length === 0) {
-      throw new BadRequestException({ code: 'NO_CHANGES', message: 'No se recibieron cambios' });
-    }
-    return this.dataSource.transaction(async (manager) => {
-      const target = await this.lockTarget(manager, id);
-      const campaign = await this.lockCampaign(manager, target.campaignId);
-      this.assertCampaignEditable(campaign);
-      this.assertTargetPlanningEditable(target);
-      const before = await this.loadTargetView(manager, id);
-      if (dto.dueAt !== undefined) target.dueAt = dateValue(dto.dueAt);
-      if (dto.instructions !== undefined) target.instructions = dto.instructions;
-      target.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaignTarget).save(target);
-      campaign.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaign).save(campaign);
-      const updated = await this.loadTargetView(manager, id);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.SURVEY_TARGET_UPDATED,
-        entityType: 'survey_campaign_target',
-        entityId: id,
-        beforeData: before as unknown as Record<string, unknown>,
-        afterData: updated as unknown as Record<string, unknown>,
-        metadata: { campaignId: target.campaignId },
-      }, manager);
-      return this.loadCampaignView(manager, target.campaignId);
-    });
-  }
-
-  async assignTarget(
-    id: string,
-    dto: AssignSurveyTargetDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyCampaignView> {
-    return this.dataSource.transaction(async (manager) => {
-      const target = await this.lockTarget(manager, id);
-      const campaign = await this.lockCampaign(manager, target.campaignId);
-      this.assertCampaignEditable(campaign);
-      this.assertTargetPlanningEditable(target);
-      await this.requireAssignee(manager, dto.assignedUserId);
-      const beforeUserId = target.assignedUserId;
-      if (beforeUserId === dto.assignedUserId) {
-        return this.loadCampaignView(manager, target.campaignId);
-      }
-      target.assignedUserId = dto.assignedUserId;
-      target.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaignTarget).save(target);
-      campaign.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaign).save(campaign);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.SURVEY_TARGET_ASSIGNED,
-        entityType: 'survey_campaign_target',
-        entityId: id,
-        beforeData: { assignedUserId: beforeUserId },
-        afterData: { assignedUserId: dto.assignedUserId },
-        metadata: { campaignId: target.campaignId },
-      }, manager);
-      return this.loadCampaignView(manager, target.campaignId);
-    });
-  }
-
-  async changeTargetStatus(
-    id: string,
-    dto: ChangeSurveyTargetStatusDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyCampaignView> {
-    return this.dataSource.transaction(async (manager) => {
-      const target = await this.lockTarget(manager, id);
-      const campaign = await this.lockCampaign(manager, target.campaignId);
-      const planningOmission =
-        principal.permissions.includes('surveys.manage') &&
-        [SurveyCampaignStatus.DRAFT, SurveyCampaignStatus.PLANNED].includes(campaign.status) &&
-        (
-          (target.status === SurveyTargetStatus.PENDING && dto.status === SurveyTargetStatus.SKIPPED) ||
-          (target.status === SurveyTargetStatus.SKIPPED && dto.status === SurveyTargetStatus.PENDING)
-        );
-      if (campaign.status !== SurveyCampaignStatus.IN_PROGRESS && !planningOmission) {
-        throw new ConflictException({
-          code: 'SURVEY_CAMPAIGN_NOT_IN_PROGRESS',
-          message: 'La campaña debe estar en curso para registrar avance; durante la planificación sólo se puede omitir o restaurar un objetivo',
-        });
-      }
-      if (
-        !principal.permissions.includes('surveys.manage') &&
-        target.assignedUserId !== principal.userId
-      ) {
-        throw new ForbiddenException({
-          code: 'SURVEY_TARGET_NOT_ASSIGNED',
-          message: 'El objetivo no está asignado al usuario actual',
-        });
-      }
-      if (target.status === dto.status) return this.loadCampaignView(manager, target.campaignId);
-      if (!planningOmission && !targetTransitions[target.status].includes(dto.status)) {
-        throw new ConflictException({
-          code: 'SURVEY_TARGET_INVALID_TRANSITION',
-          message: `No se puede pasar el objetivo de ${target.status} a ${dto.status}`,
-        });
-      }
-      const beforeStatus = target.status;
-      target.status = dto.status;
-      target.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaignTarget).save(target);
-      campaign.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaign).save(campaign);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.SURVEY_TARGET_STATUS_CHANGED,
-        entityType: 'survey_campaign_target',
-        entityId: id,
-        beforeData: { status: beforeStatus },
-        afterData: { status: dto.status },
-        metadata: { campaignId: target.campaignId },
-      }, manager);
-      return this.loadCampaignView(manager, target.campaignId);
-    });
-  }
-
-  private campaignSelect(where: string): string {
-    return `
-      SELECT
-        campaign.id,
-        campaign.code,
-        campaign.name,
-        campaign.description,
-        campaign.status,
-        campaign.planned_start_at AS "plannedStartAt",
-        campaign.planned_end_at AS "plannedEndAt",
-        CASE WHEN scope_asset.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', scope_asset.id, 'code', scope_asset.code, 'name', scope_asset.name
-        ) END AS "scopeAsset",
-        CASE WHEN coordinator.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', coordinator.id,
-          'username', coordinator.username,
-          'firstName', coordinator.first_name,
-          'lastName', coordinator.last_name
-        ) END AS coordinator,
-        COALESCE(target_counts.total, 0)::integer AS "targetCount",
-        COALESCE(target_counts.pending, 0)::integer AS "pendingCount",
-        COALESCE(target_counts.in_progress, 0)::integer AS "inProgressCount",
-        COALESCE(target_counts.submitted, 0)::integer AS "submittedCount",
-        COALESCE(target_counts.completed, 0)::integer AS "completedCount",
-        COALESCE(target_counts.skipped, 0)::integer AS "skippedCount",
-        campaign.created_at AS "createdAt",
-        campaign.updated_at AS "updatedAt"
-      FROM survey_campaigns campaign
-      LEFT JOIN assets scope_asset ON scope_asset.id = campaign.scope_asset_id
-      LEFT JOIN users coordinator ON coordinator.id = campaign.coordinator_user_id
-      LEFT JOIN LATERAL (
-        SELECT
-          COUNT(*) AS total,
-          COUNT(*) FILTER (WHERE target.status = 'PENDING') AS pending,
-          COUNT(*) FILTER (WHERE target.status = 'IN_PROGRESS') AS in_progress,
-          COUNT(*) FILTER (WHERE target.status = 'SUBMITTED') AS submitted,
-          COUNT(*) FILTER (WHERE target.status = 'COMPLETED') AS completed,
-          COUNT(*) FILTER (WHERE target.status = 'SKIPPED') AS skipped
-        FROM survey_campaign_targets target
-        WHERE target.campaign_id = campaign.id
-      ) target_counts ON true
-      ${where}
-    `;
-  }
-
-  private async loadCampaignView(
-    manager: EntityManager,
-    id: string,
-  ): Promise<SurveyCampaignView> {
-    const [campaign] = (await manager.query(
-      this.campaignSelect('WHERE campaign.id = $1'),
-      [id],
-    )) as SurveyCampaignListItem[];
-    if (!campaign) throw campaignNotFound();
-    const targets = (await manager.query(`
-      ${this.targetSelect()}
-      WHERE target.campaign_id = $1
-      ORDER BY
-        CASE target.status
-          WHEN 'SUBMITTED' THEN 1 WHEN 'IN_PROGRESS' THEN 2 WHEN 'PENDING' THEN 3
-          WHEN 'COMPLETED' THEN 4 ELSE 5
-        END,
-        target.due_at NULLS LAST,
-        asset.code
-    `, [id])) as SurveyTargetView[];
-    return { ...campaign, targets };
-  }
-
-  private async loadTargetView(manager: EntityManager, id: string): Promise<SurveyTargetView> {
-    const [target] = (await manager.query(`
-      ${this.targetSelect()} WHERE target.id = $1
-    `, [id])) as SurveyTargetView[];
-    if (!target) throw targetNotFound();
-    return target;
-  }
-
-  private targetSelect(): string {
-    return `
-      SELECT
-        target.id,
-        target.campaign_id AS "campaignId",
-        JSONB_BUILD_OBJECT(
-          'id', asset.id,
-          'code', asset.code,
-          'name', asset.name,
-          'typeName', asset_type.name
-        ) AS asset,
-        CASE WHEN assignee.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', assignee.id,
-          'username', assignee.username,
-          'firstName', assignee.first_name,
-          'lastName', assignee.last_name
-        ) END AS "assignedUser",
-        target.status,
-        target.due_at AS "dueAt",
-        target.instructions,
-        target.created_at AS "createdAt",
-        target.updated_at AS "updatedAt"
-      FROM survey_campaign_targets target
-      INNER JOIN assets asset ON asset.id = target.asset_id
-      INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
-      LEFT JOIN users assignee ON assignee.id = target.assigned_user_id
-    `;
-  }
-
-  private async lockCampaign(manager: EntityManager, id: string): Promise<SurveyCampaign> {
-    const campaign = await manager.getRepository(SurveyCampaign)
-      .createQueryBuilder('campaign')
-      .where('campaign.id = :id', { id })
-      .setLock('pessimistic_write')
-      .getOne();
-    if (!campaign) throw campaignNotFound();
-    return campaign;
-  }
-
-  private async lockTarget(manager: EntityManager, id: string): Promise<SurveyCampaignTarget> {
-    const target = await manager.getRepository(SurveyCampaignTarget)
-      .createQueryBuilder('target')
-      .where('target.id = :id', { id })
-      .setLock('pessimistic_write')
-      .getOne();
-    if (!target) throw targetNotFound();
-    return target;
-  }
-
-  private async requireAsset(manager: EntityManager, id: string | null): Promise<void> {
-    if (!id) return;
-    const rows = await manager.query(`SELECT 1 FROM assets WHERE id = $1`, [id]) as unknown[];
-    if (rows.length === 0) {
-      throw new BadRequestException({
-        code: 'SURVEY_ASSET_NOT_FOUND',
-        message: 'El activo seleccionado no existe',
-      });
-    }
-  }
-
-  private async requireActiveUser(manager: EntityManager, id: string | null): Promise<void> {
-    if (!id) return;
-    const rows = await manager.query(
-      `SELECT 1 FROM users WHERE id = $1 AND status = 'ACTIVE'`,
-      [id],
-    ) as unknown[];
-    if (rows.length === 0) {
-      throw new BadRequestException({
-        code: 'SURVEY_USER_NOT_ACTIVE',
-        message: 'El usuario seleccionado no existe o está inactivo',
-      });
-    }
-  }
-
-  private async requireAssignee(manager: EntityManager, id: string | null): Promise<void> {
-    if (!id) return;
-    const rows = await manager.query(`
-      SELECT 1
-      FROM users user_account
-      WHERE user_account.id = $1
-        AND user_account.status = 'ACTIVE'
-        AND EXISTS (
-          SELECT 1
-          FROM user_roles user_role
-          INNER JOIN role_permissions role_permission ON role_permission.role_id = user_role.role_id
-          INNER JOIN permissions permission ON permission.id = role_permission.permission_id
-          WHERE user_role.user_id = user_account.id
-            AND permission.code = 'surveys.execute'
-        )
-    `, [id]) as unknown[];
-    if (rows.length === 0) {
-      throw new BadRequestException({
-        code: 'SURVEY_ASSIGNEE_INVALID',
-        message: 'El responsable debe ser un usuario activo con permiso de ejecución',
-      });
-    }
-  }
-
-  private async assertAssetInScope(
-    manager: EntityManager,
-    assetId: string,
-    scopeAssetId: string | null,
-  ): Promise<void> {
-    if (!scopeAssetId) return;
-    const rows = await manager.query(`
-      WITH RECURSIVE ancestors AS (
-        SELECT id, parent_id FROM assets WHERE id = $1
-        UNION ALL
-        SELECT parent.id, parent.parent_id
-        FROM assets parent
-        INNER JOIN ancestors child ON child.parent_id = parent.id
-      )
-      SELECT 1 FROM ancestors WHERE id = $2
-    `, [assetId, scopeAssetId]) as unknown[];
-    if (rows.length === 0) {
-      throw new BadRequestException({
-        code: 'SURVEY_TARGET_OUTSIDE_SCOPE',
-        message: 'El activo no pertenece al alcance jerárquico de la campaña',
-      });
-    }
-  }
-
-  private async assertCampaignTargetsInScope(
-    manager: EntityManager,
-    campaignId: string,
-    scopeAssetId: string | null,
-  ): Promise<void> {
-    if (!scopeAssetId) return;
-    const [row] = (await manager.query(`
-      SELECT COUNT(*)::integer AS outside
-      FROM survey_campaign_targets target
-      WHERE target.campaign_id = $1
-        AND NOT EXISTS (
-          WITH RECURSIVE ancestors AS (
-            SELECT id, parent_id FROM assets WHERE id = target.asset_id
-            UNION ALL
-            SELECT parent.id, parent.parent_id
-            FROM assets parent
-            INNER JOIN ancestors child ON child.parent_id = parent.id
-          )
-          SELECT 1 FROM ancestors WHERE id = $2
-        )
-    `, [campaignId, scopeAssetId])) as Array<{ outside: number }>;
-    if (Number(row?.outside ?? 0) > 0) {
-      throw new ConflictException({
-        code: 'SURVEY_SCOPE_EXCLUDES_TARGETS',
-        message: 'El nuevo alcance dejaría objetivos existentes fuera de la campaña',
-      });
-    }
-  }
-
-  private async validateDates(
-    start: string | Date | null,
-    end: string | Date | null,
-  ): Promise<void> {
-    if (start && end && new Date(end).getTime() < new Date(start).getTime()) {
-      throw new BadRequestException({
-        code: 'SURVEY_INVALID_DATES',
-        message: 'La fecha de finalización no puede ser anterior al inicio',
-      });
-    }
-  }
-
-  private assertCampaignEditable(campaign: SurveyCampaign): void {
-    if (
-      campaign.status === SurveyCampaignStatus.COMPLETED ||
-      campaign.status === SurveyCampaignStatus.CANCELLED
-    ) {
-      throw new ConflictException({
-        code: 'SURVEY_CAMPAIGN_CLOSED',
-        message: 'Una campaña completada o cancelada ya no puede modificarse',
-      });
-    }
-  }
-
-  private assertTargetPlanningEditable(target: SurveyCampaignTarget): void {
-    if (
-      target.status === SurveyTargetStatus.SUBMITTED ||
-      target.status === SurveyTargetStatus.COMPLETED
-    ) {
-      throw new ConflictException({
-        code: 'SURVEY_TARGET_PLANNING_LOCKED',
-        message: 'Un objetivo enviado o completado ya no puede replanificarse',
-      });
-    }
-  }
-
-  private campaignConflict(): ConflictException {
-    return new ConflictException({
-      code: 'SURVEY_CAMPAIGN_CODE_EXISTS',
-      message: 'Ya existe una campaña con ese código',
-    });
-  }
-
-  private auditCampaign(campaign: SurveyCampaignView): Record<string, unknown> {
-    const { targets: _targets, ...summary } = campaign;
-    return summary as unknown as Record<string, unknown>;
-  }
-}

From de8795274329039c8fc5ee55a8ca6e894143d6ee Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:15:29 -0300
Subject: [PATCH 116/224] F4: remove survey planning DTOs

---
 .../dto/add-survey-target.dto.ts              | 23 -------------------
 1 file changed, 23 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/add-survey-target.dto.ts

diff --git a/api-v3/src/survey-planning/dto/add-survey-target.dto.ts b/api-v3/src/survey-planning/dto/add-survey-target.dto.ts
deleted file mode 100644
index 1842129..0000000
--- a/api-v3/src/survey-planning/dto/add-survey-target.dto.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { Transform } from 'class-transformer';
-import { IsISO8601, IsOptional, IsString, IsUUID, MaxLength } from 'class-validator';
-
-export class AddSurveyTargetDto {
-  @IsUUID('4')
-  assetId!: string;
-
-  @IsOptional()
-  @IsUUID('4')
-  assignedUserId?: string | null;
-
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  dueAt?: string | null;
-
-  @IsOptional()
-  @Transform(({ value }) =>
-    typeof value === 'string' && value.trim() ? value.trim() : null,
-  )
-  @IsString()
-  @MaxLength(4000)
-  instructions?: string | null;
-}

From dea007581ccd9ae09b1101e3d84c4141501f7c91 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:15:41 -0300
Subject: [PATCH 117/224] F4: remove survey planning DTOs

---
 api-v3/src/survey-planning/dto/assign-survey-target.dto.ts | 7 -------
 1 file changed, 7 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/assign-survey-target.dto.ts

diff --git a/api-v3/src/survey-planning/dto/assign-survey-target.dto.ts b/api-v3/src/survey-planning/dto/assign-survey-target.dto.ts
deleted file mode 100644
index 84bf835..0000000
--- a/api-v3/src/survey-planning/dto/assign-survey-target.dto.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { IsOptional, IsUUID } from 'class-validator';
-
-export class AssignSurveyTargetDto {
-  @IsOptional()
-  @IsUUID('4')
-  assignedUserId!: string | null;
-}

From 29864fb2ae6b9565de95fd1563daf57d008c1321 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:15:51 -0300
Subject: [PATCH 118/224] F4: remove survey planning DTOs

---
 .../dto/change-survey-campaign-status.dto.ts               | 7 -------
 1 file changed, 7 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/change-survey-campaign-status.dto.ts

diff --git a/api-v3/src/survey-planning/dto/change-survey-campaign-status.dto.ts b/api-v3/src/survey-planning/dto/change-survey-campaign-status.dto.ts
deleted file mode 100644
index 253e16e..0000000
--- a/api-v3/src/survey-planning/dto/change-survey-campaign-status.dto.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { IsEnum } from 'class-validator';
-import { SurveyCampaignStatus } from '../../database/entities';
-
-export class ChangeSurveyCampaignStatusDto {
-  @IsEnum(SurveyCampaignStatus)
-  status!: SurveyCampaignStatus;
-}

From 3d3d89a76a42a0e2d8af833fdbf534b7f4ecb874 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:15:59 -0300
Subject: [PATCH 119/224] F4: remove survey planning DTOs

---
 .../survey-planning/dto/change-survey-target-status.dto.ts | 7 -------
 1 file changed, 7 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/change-survey-target-status.dto.ts

diff --git a/api-v3/src/survey-planning/dto/change-survey-target-status.dto.ts b/api-v3/src/survey-planning/dto/change-survey-target-status.dto.ts
deleted file mode 100644
index 760b817..0000000
--- a/api-v3/src/survey-planning/dto/change-survey-target-status.dto.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { IsEnum } from 'class-validator';
-import { SurveyTargetStatus } from '../../database/entities';
-
-export class ChangeSurveyTargetStatusDto {
-  @IsEnum(SurveyTargetStatus)
-  status!: SurveyTargetStatus;
-}

From 5b22dde1c6c0389c748b64959208c6a064e4221b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:16:07 -0300
Subject: [PATCH 120/224] F4: remove survey planning DTOs

---
 .../dto/create-survey-campaign.dto.ts         | 51 -------------------
 1 file changed, 51 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/create-survey-campaign.dto.ts

diff --git a/api-v3/src/survey-planning/dto/create-survey-campaign.dto.ts b/api-v3/src/survey-planning/dto/create-survey-campaign.dto.ts
deleted file mode 100644
index dcea6a9..0000000
--- a/api-v3/src/survey-planning/dto/create-survey-campaign.dto.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { Transform } from 'class-transformer';
-import {
-  IsISO8601,
-  IsOptional,
-  IsString,
-  IsUUID,
-  Matches,
-  MaxLength,
-  MinLength,
-} from 'class-validator';
-
-export class CreateSurveyCampaignDto {
-  @Transform(({ value }) =>
-    typeof value === 'string' ? value.trim().toUpperCase() : value,
-  )
-  @IsString()
-  @MinLength(1)
-  @MaxLength(80)
-  @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(4000)
-  description?: string | null;
-
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  plannedStartAt?: string | null;
-
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  plannedEndAt?: string | null;
-
-  @IsOptional()
-  @IsUUID('4')
-  scopeAssetId?: string | null;
-
-  @IsOptional()
-  @IsUUID('4')
-  coordinatorUserId?: string | null;
-}

From 89f48dd82de59302ec9eef2faa4f4913cb311d2e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:16:14 -0300
Subject: [PATCH 121/224] F4: remove survey planning DTOs

---
 .../dto/list-survey-campaigns-query.dto.ts    | 40 -------------------
 1 file changed, 40 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/list-survey-campaigns-query.dto.ts

diff --git a/api-v3/src/survey-planning/dto/list-survey-campaigns-query.dto.ts b/api-v3/src/survey-planning/dto/list-survey-campaigns-query.dto.ts
deleted file mode 100644
index fa37549..0000000
--- a/api-v3/src/survey-planning/dto/list-survey-campaigns-query.dto.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { Type } from 'class-transformer';
-import {
-  IsEnum,
-  IsInt,
-  IsOptional,
-  IsString,
-  IsUUID,
-  Max,
-  MaxLength,
-  Min,
-} from 'class-validator';
-import { SurveyCampaignStatus } from '../../database/entities';
-
-export class ListSurveyCampaignsQueryDto {
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  page = 1;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  @Max(100)
-  pageSize = 25;
-
-  @IsOptional()
-  @IsString()
-  @MaxLength(200)
-  search?: string;
-
-  @IsOptional()
-  @IsEnum(SurveyCampaignStatus)
-  status?: SurveyCampaignStatus;
-
-  @IsOptional()
-  @IsUUID('4')
-  coordinatorUserId?: string;
-}

From 73eb6fc192553195d655b0424dfbbe3a269caf5f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:16:24 -0300
Subject: [PATCH 122/224] F4: remove survey planning DTOs

---
 .../dto/update-survey-campaign.dto.ts         | 53 -------------------
 1 file changed, 53 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/update-survey-campaign.dto.ts

diff --git a/api-v3/src/survey-planning/dto/update-survey-campaign.dto.ts b/api-v3/src/survey-planning/dto/update-survey-campaign.dto.ts
deleted file mode 100644
index 5beed45..0000000
--- a/api-v3/src/survey-planning/dto/update-survey-campaign.dto.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { Transform } from 'class-transformer';
-import {
-  IsISO8601,
-  IsOptional,
-  IsString,
-  IsUUID,
-  Matches,
-  MaxLength,
-  MinLength,
-} from 'class-validator';
-
-export class UpdateSurveyCampaignDto {
-  @IsOptional()
-  @Transform(({ value }) =>
-    typeof value === 'string' ? value.trim().toUpperCase() : value,
-  )
-  @IsString()
-  @MinLength(1)
-  @MaxLength(80)
-  @Matches(/^[A-Z0-9][A-Z0-9._/-]*$/)
-  code?: string;
-
-  @IsOptional()
-  @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(4000)
-  description?: string | null;
-
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  plannedStartAt?: string | null;
-
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  plannedEndAt?: string | null;
-
-  @IsOptional()
-  @IsUUID('4')
-  scopeAssetId?: string | null;
-
-  @IsOptional()
-  @IsUUID('4')
-  coordinatorUserId?: string | null;
-}

From e2049b084fce058238b3a0ba93e718a8da3bc4fb Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:16:33 -0300
Subject: [PATCH 123/224] F4: remove survey planning DTOs

---
 .../dto/update-survey-target.dto.ts              | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 api-v3/src/survey-planning/dto/update-survey-target.dto.ts

diff --git a/api-v3/src/survey-planning/dto/update-survey-target.dto.ts b/api-v3/src/survey-planning/dto/update-survey-target.dto.ts
deleted file mode 100644
index b3c9acc..0000000
--- a/api-v3/src/survey-planning/dto/update-survey-target.dto.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { Transform } from 'class-transformer';
-import { IsISO8601, IsOptional, IsString, MaxLength } from 'class-validator';
-
-export class UpdateSurveyTargetDto {
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  dueAt?: string | null;
-
-  @IsOptional()
-  @Transform(({ value }) =>
-    typeof value === 'string' && value.trim() ? value.trim() : null,
-  )
-  @IsString()
-  @MaxLength(4000)
-  instructions?: string | null;
-}

From cbf8f0c73878aba7bb912898d63625f7d8474fb4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Mon, 7 Sep 2026 23:16:42 -0300
Subject: [PATCH 124/224] F4: remove obsolete survey execution controller

---
 .../survey-execution.controller.ts            | 61 -------------------
 1 file changed, 61 deletions(-)
 delete mode 100644 api-v3/src/survey-execution/survey-execution.controller.ts

diff --git a/api-v3/src/survey-execution/survey-execution.controller.ts b/api-v3/src/survey-execution/survey-execution.controller.ts
deleted file mode 100644
index 8d8790c..0000000
--- a/api-v3/src/survey-execution/survey-execution.controller.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Param,
-  ParseUUIDPipe,
-  Post,
-  Put,
-  Req,
-} from '@nestjs/common';
-import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
-import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
-import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { ReviewSurveyReportDto } from './dto/review-survey-report.dto';
-import { SaveSurveyReportDto } from './dto/save-survey-report.dto';
-import { SurveyExecutionService } from './survey-execution.service';
-
-@Controller('survey-campaign-targets/:targetId/report')
-export class SurveyExecutionController {
-  constructor(private readonly execution: SurveyExecutionService) {}
-
-  @Get()
-  @RequirePermissions('surveys.read_reports')
-  get(
-    @Param('targetId', new ParseUUIDPipe({ version: '4' })) targetId: string,
-  ) {
-    return this.execution.get(targetId);
-  }
-
-  @Put()
-  @RequirePermissions('surveys.capture')
-  save(
-    @Param('targetId', new ParseUUIDPipe({ version: '4' })) targetId: string,
-    @Body() dto: SaveSurveyReportDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.execution.save(targetId, dto, principal, request);
-  }
-
-  @Post('submit')
-  @RequirePermissions('surveys.capture')
-  submit(
-    @Param('targetId', new ParseUUIDPipe({ version: '4' })) targetId: string,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.execution.submit(targetId, principal, request);
-  }
-
-  @Post('review')
-  @RequirePermissions('surveys.review')
-  review(
-    @Param('targetId', new ParseUUIDPipe({ version: '4' })) targetId: string,
-    @Body() dto: ReviewSurveyReportDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.execution.review(targetId, dto, principal, request);
-  }
-}

From 50728e83bac4d9722d29bd48e27278c8796cd8ff Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:27:00 -0300
Subject: [PATCH 125/224] F4: remove legacy survey execution module

---
 .../src/survey-execution/survey-execution.module.ts  | 12 ------------
 1 file changed, 12 deletions(-)
 delete mode 100644 api-v3/src/survey-execution/survey-execution.module.ts

diff --git a/api-v3/src/survey-execution/survey-execution.module.ts b/api-v3/src/survey-execution/survey-execution.module.ts
deleted file mode 100644
index 6e0bf58..0000000
--- a/api-v3/src/survey-execution/survey-execution.module.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { Module } from '@nestjs/common';
-import { AssetMasterModule } from '../asset-master/asset-master.module';
-import { AuditModule } from '../audit/audit.module';
-import { SurveyExecutionController } from './survey-execution.controller';
-import { SurveyExecutionService } from './survey-execution.service';
-
-@Module({
-  imports: [AuditModule, AssetMasterModule],
-  controllers: [SurveyExecutionController],
-  providers: [SurveyExecutionService],
-})
-export class SurveyExecutionModule {}

From 46c2abb4d1c9edcd4f4b2f901d1b514705a5d833 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:27:10 -0300
Subject: [PATCH 126/224] F4: remove legacy survey execution service

---
 .../survey-execution.service.ts               | 924 ------------------
 1 file changed, 924 deletions(-)
 delete mode 100644 api-v3/src/survey-execution/survey-execution.service.ts

diff --git a/api-v3/src/survey-execution/survey-execution.service.ts b/api-v3/src/survey-execution/survey-execution.service.ts
deleted file mode 100644
index a0d16a8..0000000
--- a/api-v3/src/survey-execution/survey-execution.service.ts
+++ /dev/null
@@ -1,924 +0,0 @@
-import {
-  BadRequestException,
-  ConflictException,
-  ForbiddenException,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-import { DataSource, EntityManager } from 'typeorm';
-import { administrationAuditContext } from '../administration/common/administration-audit';
-import { AssetHistoryService } from '../asset-master/asset-history.service';
-import { AuditService } from '../audit/audit.service';
-import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import {
-  Asset,
-  AssetDataOrigin,
-  AssetInformationStatus,
-  AssetVersionChangeType,
-  AuditAction,
-  SurveyCampaign,
-  SurveyCampaignStatus,
-  SurveyCampaignTarget,
-  SurveyReportOutcome,
-  SurveyReportStatus,
-  SurveyReportVersionEvent,
-  SurveyTargetReport,
-  SurveyTargetStatus,
-} from '../database/entities';
-import {
-  SurveyReviewDecision,
-  type ReviewSurveyReportDto,
-} from './dto/review-survey-report.dto';
-import type { SaveSurveyReportDto } from './dto/save-survey-report.dto';
-
-interface ExecutionPerson {
-  id: string;
-  username: string;
-  firstName: string;
-  lastName: string;
-}
-
-interface ExecutionContextView {
-  target: {
-    id: string;
-    status: SurveyTargetStatus;
-    dueAt: Date | null;
-    instructions: string | null;
-    assignedUser: ExecutionPerson | null;
-  };
-  campaign: {
-    id: string;
-    code: string;
-    name: string;
-    status: SurveyCampaignStatus;
-  };
-  asset: {
-    id: string;
-    code: string;
-    name: string;
-    typeName: string;
-    informationStatus: AssetInformationStatus;
-    currentVersion: number;
-  };
-}
-
-interface SurveyReportView {
-  id: string;
-  targetId: string;
-  outcome: SurveyReportOutcome | null;
-  status: SurveyReportStatus;
-  observedAt: Date | null;
-  latitude: number | null;
-  longitude: number | null;
-  accuracyM: number | null;
-  notes: string | null;
-  assetVersionAtSubmission: number | null;
-  submittedAt: Date | null;
-  submittedBy: ExecutionPerson | null;
-  reviewedAt: Date | null;
-  reviewedBy: ExecutionPerson | null;
-  reviewNotes: string | null;
-  selectedMediaIds: string[];
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-interface ReportMediaView {
-  id: string;
-  kind: 'PHOTO';
-  originalName: string;
-  mimeType: string;
-  sizeBytes: number;
-  sha256: string;
-  title: string | null;
-  description: string | null;
-  capturedAt: Date | null;
-  latitude: number | null;
-  longitude: number | null;
-  accuracyM: number | null;
-  source: string;
-  createdAt: Date;
-  selected: boolean;
-}
-
-interface ReportVersionView {
-  id: string;
-  versionNumber: number;
-  event: SurveyReportVersionEvent;
-  snapshot: Record<string, unknown>;
-  actorUserId: string | null;
-  actorUsername: string | null;
-  createdAt: Date;
-}
-
-export interface SurveyExecutionView extends ExecutionContextView {
-  report: SurveyReportView | null;
-  availableMedia: ReportMediaView[];
-  versions: ReportVersionView[];
-}
-
-function targetNotFound(): NotFoundException {
-  return new NotFoundException({
-    code: 'SURVEY_TARGET_NOT_FOUND',
-    message: 'Objetivo de relevamiento no encontrado',
-  });
-}
-
-function reportNotFound(): NotFoundException {
-  return new NotFoundException({
-    code: 'SURVEY_REPORT_NOT_FOUND',
-    message: 'El objetivo todavía no tiene un informe de campo',
-  });
-}
-
-@Injectable()
-export class SurveyExecutionService {
-  constructor(
-    private readonly dataSource: DataSource,
-    private readonly audit: AuditService,
-    private readonly history: AssetHistoryService,
-  ) {}
-
-  async get(targetId: string): Promise<SurveyExecutionView> {
-    return this.dataSource.transaction((manager) => this.loadView(manager, targetId));
-  }
-
-  async save(
-    targetId: string,
-    dto: SaveSurveyReportDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyExecutionView> {
-    return this.dataSource.transaction(async (manager) => {
-      const { target, campaign } = await this.lockTargetContext(manager, targetId);
-      this.assertCaptureAllowed(target, campaign, principal);
-      const repository = manager.getRepository(SurveyTargetReport);
-      let report = await this.lockReport(manager, targetId, false);
-      const before = report ? this.reportAuditView(report) : null;
-      if (!report) {
-        report = repository.create({
-          targetId,
-          outcome: null,
-          status: SurveyReportStatus.DRAFT,
-          observedAt: null,
-          latitude: null,
-          longitude: null,
-          accuracyM: null,
-          notes: null,
-          assetVersionAtSubmission: null,
-          submittedAt: null,
-          submittedBy: null,
-          reviewedAt: null,
-          reviewedBy: null,
-          reviewNotes: null,
-          createdBy: principal.userId,
-          updatedBy: principal.userId,
-        });
-      } else if (
-        report.status === SurveyReportStatus.SUBMITTED ||
-        report.status === SurveyReportStatus.APPROVED
-      ) {
-        throw new ConflictException({
-          code: 'SURVEY_REPORT_LOCKED',
-          message: 'El informe enviado o aprobado ya no puede editarse',
-        });
-      }
-
-      const nextLatitude = dto.latitude === undefined
-        ? this.numberOrNull(report.latitude)
-        : dto.latitude;
-      const nextLongitude = dto.longitude === undefined
-        ? this.numberOrNull(report.longitude)
-        : dto.longitude;
-      const nextAccuracy = dto.accuracyM === undefined
-        ? this.numberOrNull(report.accuracyM)
-        : dto.accuracyM;
-      this.assertCoordinatePair(nextLatitude, nextLongitude, nextAccuracy);
-      await this.validateMedia(manager, target.assetId, dto.mediaIds);
-
-      if (dto.outcome !== undefined) report.outcome = dto.outcome;
-      if (dto.observedAt !== undefined) {
-        report.observedAt = dto.observedAt ? new Date(dto.observedAt) : null;
-      }
-      if (dto.latitude !== undefined) {
-        report.latitude = dto.latitude == null ? null : String(dto.latitude);
-      }
-      if (dto.longitude !== undefined) {
-        report.longitude = dto.longitude == null ? null : String(dto.longitude);
-      }
-      if (dto.accuracyM !== undefined) {
-        report.accuracyM = dto.accuracyM == null ? null : String(dto.accuracyM);
-      }
-      if (dto.notes !== undefined) report.notes = dto.notes?.trim() || null;
-      if (report.status === SurveyReportStatus.REJECTED) {
-        report.status = SurveyReportStatus.DRAFT;
-        report.assetVersionAtSubmission = null;
-        report.submittedAt = null;
-        report.submittedBy = null;
-        report.reviewedAt = null;
-        report.reviewedBy = null;
-        report.reviewNotes = null;
-      }
-      report.updatedBy = principal.userId;
-      await repository.save(report);
-      await this.replaceMediaSelection(manager, report.id, dto.mediaIds, principal.userId);
-
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.SURVEY_REPORT_SAVED,
-        entityType: 'survey_target_report',
-        entityId: report.id,
-        beforeData: before,
-        afterData: this.reportAuditView(report),
-        metadata: { targetId, mediaCount: dto.mediaIds.length },
-      }, manager);
-      return this.loadView(manager, targetId);
-    });
-  }
-
-  async submit(
-    targetId: string,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyExecutionView> {
-    return this.dataSource.transaction(async (manager) => {
-      const { target, campaign } = await this.lockTargetContext(manager, targetId);
-      this.assertCaptureAllowed(target, campaign, principal);
-      const report = await this.lockReport(manager, targetId, true);
-      if (!report) throw reportNotFound();
-      if (report.status !== SurveyReportStatus.DRAFT) {
-        throw new ConflictException({
-          code: 'SURVEY_REPORT_NOT_DRAFT',
-          message: 'Sólo se puede enviar un informe guardado como borrador',
-        });
-      }
-      await this.assertComplete(manager, report);
-
-      const asset = await this.lockAsset(manager, target.assetId);
-      const beforeAsset = this.assetAuditView(asset);
-      asset.informationStatus = report.outcome === SurveyReportOutcome.NOT_LOCATED
-        ? AssetInformationStatus.OBSERVED
-        : AssetInformationStatus.SURVEYED;
-      asset.dataOrigin = AssetDataOrigin.FIELD_SURVEY;
-      asset.sourceName = `Relevamiento ${campaign.code}`;
-      asset.sourceReference = `survey-report:${report.id}`;
-      asset.sourceObservedAt = report.observedAt;
-      asset.sourceNotes = report.notes;
-      asset.provenanceVerifiedAt = null;
-      asset.provenanceVerifiedBy = null;
-      asset.provenanceUpdatedAt = new Date();
-      asset.provenanceUpdatedBy = principal.userId;
-      asset.updatedBy = principal.userId;
-      await manager.getRepository(Asset).save(asset);
-      const assetVersion = await this.history.capture(
-        manager,
-        asset.id,
-        AssetVersionChangeType.PROVENANCE_UPDATED,
-        principal,
-        request,
-      );
-      asset.currentVersion = assetVersion;
-
-      report.status = SurveyReportStatus.SUBMITTED;
-      report.assetVersionAtSubmission = assetVersion;
-      report.submittedAt = new Date();
-      report.submittedBy = principal.userId;
-      report.reviewedAt = null;
-      report.reviewedBy = null;
-      report.reviewNotes = null;
-      report.updatedBy = principal.userId;
-      await manager.getRepository(SurveyTargetReport).save(report);
-
-      target.status = SurveyTargetStatus.SUBMITTED;
-      target.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaignTarget).save(target);
-      campaign.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaign).save(campaign);
-
-      const reportVersion = await this.captureReportVersion(
-        manager,
-        report,
-        SurveyReportVersionEvent.SUBMITTED,
-        principal,
-      );
-      await this.recordAssetChange(
-        manager,
-        asset,
-        beforeAsset,
-        AuditAction.ASSET_PROVENANCE_UPDATED,
-        principal,
-        request,
-        targetId,
-        assetVersion,
-      );
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.SURVEY_REPORT_SUBMITTED,
-        entityType: 'survey_target_report',
-        entityId: report.id,
-        afterData: this.reportAuditView(report),
-        metadata: { targetId, assetId: asset.id, assetVersion, reportVersion },
-      }, manager);
-      return this.loadView(manager, targetId);
-    });
-  }
-
-  async review(
-    targetId: string,
-    dto: ReviewSurveyReportDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<SurveyExecutionView> {
-    return this.dataSource.transaction(async (manager) => {
-      const { target, campaign } = await this.lockTargetContext(manager, targetId);
-      if (campaign.status !== SurveyCampaignStatus.IN_PROGRESS) {
-        throw new ConflictException({
-          code: 'SURVEY_CAMPAIGN_NOT_IN_PROGRESS',
-          message: 'La campaña debe estar en curso para revisar informes',
-        });
-      }
-      const report = await this.lockReport(manager, targetId, true);
-      if (!report) throw reportNotFound();
-      if (report.status !== SurveyReportStatus.SUBMITTED || target.status !== SurveyTargetStatus.SUBMITTED) {
-        throw new ConflictException({
-          code: 'SURVEY_REPORT_NOT_SUBMITTED',
-          message: 'El informe no está pendiente de revisión',
-        });
-      }
-      const notes = dto.notes?.trim() || null;
-      if (dto.decision === SurveyReviewDecision.REJECT && (!notes || notes.length < 10)) {
-        throw new BadRequestException({
-          code: 'SURVEY_REJECTION_REASON_REQUIRED',
-          message: 'Indicá un motivo de rechazo de al menos 10 caracteres',
-        });
-      }
-
-      const asset = await this.lockAsset(manager, target.assetId);
-      if (
-        dto.decision === SurveyReviewDecision.APPROVE &&
-        asset.currentVersion !== report.assetVersionAtSubmission
-      ) {
-        throw new ConflictException({
-          code: 'SURVEY_ASSET_CHANGED_AFTER_SUBMISSION',
-          message: 'El activo cambió después del envío; rechazá el informe para que sea revisado nuevamente',
-        });
-      }
-      const beforeAsset = this.assetAuditView(asset);
-      let assetVersion = asset.currentVersion;
-
-      if (dto.decision === SurveyReviewDecision.APPROVE) {
-        if (report.outcome !== SurveyReportOutcome.NOT_LOCATED) {
-          asset.informationStatus = AssetInformationStatus.VALIDATED;
-          asset.provenanceVerifiedAt = new Date();
-          asset.provenanceVerifiedBy = principal.userId;
-          asset.provenanceUpdatedAt = new Date();
-          asset.provenanceUpdatedBy = principal.userId;
-          asset.updatedBy = principal.userId;
-          await manager.getRepository(Asset).save(asset);
-          assetVersion = await this.history.capture(
-            manager,
-            asset.id,
-            AssetVersionChangeType.PROVENANCE_VERIFIED,
-            principal,
-            request,
-          );
-          asset.currentVersion = assetVersion;
-          await this.recordAssetChange(
-            manager,
-            asset,
-            beforeAsset,
-            AuditAction.ASSET_PROVENANCE_VERIFIED,
-            principal,
-            request,
-            targetId,
-            assetVersion,
-          );
-        }
-        report.status = SurveyReportStatus.APPROVED;
-        target.status = SurveyTargetStatus.COMPLETED;
-      } else {
-        const assetStillMatchesSubmission =
-          asset.currentVersion === report.assetVersionAtSubmission;
-        const assetNeedsUpdate = assetStillMatchesSubmission && (
-          asset.informationStatus !== AssetInformationStatus.OBSERVED ||
-          asset.provenanceVerifiedAt !== null ||
-          asset.provenanceVerifiedBy !== null
-        );
-        if (assetNeedsUpdate) {
-          asset.informationStatus = AssetInformationStatus.OBSERVED;
-          asset.provenanceVerifiedAt = null;
-          asset.provenanceVerifiedBy = null;
-          asset.provenanceUpdatedAt = new Date();
-          asset.provenanceUpdatedBy = principal.userId;
-          asset.updatedBy = principal.userId;
-          await manager.getRepository(Asset).save(asset);
-          assetVersion = await this.history.capture(
-            manager,
-            asset.id,
-            AssetVersionChangeType.STATUS_CHANGED,
-            principal,
-            request,
-          );
-          asset.currentVersion = assetVersion;
-          await this.recordAssetChange(
-            manager,
-            asset,
-            beforeAsset,
-            AuditAction.ASSET_INFORMATION_STATUS_CHANGED,
-            principal,
-            request,
-            targetId,
-            assetVersion,
-          );
-        }
-        report.status = SurveyReportStatus.REJECTED;
-        target.status = SurveyTargetStatus.IN_PROGRESS;
-      }
-
-      report.reviewedAt = new Date();
-      report.reviewedBy = principal.userId;
-      report.reviewNotes = notes;
-      report.updatedBy = principal.userId;
-      await manager.getRepository(SurveyTargetReport).save(report);
-      target.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaignTarget).save(target);
-      campaign.updatedBy = principal.userId;
-      await manager.getRepository(SurveyCampaign).save(campaign);
-
-      const event = dto.decision === SurveyReviewDecision.APPROVE
-        ? SurveyReportVersionEvent.APPROVED
-        : SurveyReportVersionEvent.REJECTED;
-      const reportVersion = await this.captureReportVersion(manager, report, event, principal);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: dto.decision === SurveyReviewDecision.APPROVE
-          ? AuditAction.SURVEY_REPORT_APPROVED
-          : AuditAction.SURVEY_REPORT_REJECTED,
-        entityType: 'survey_target_report',
-        entityId: report.id,
-        afterData: this.reportAuditView(report),
-        metadata: { targetId, assetId: asset.id, assetVersion, reportVersion },
-      }, manager);
-      return this.loadView(manager, targetId);
-    });
-  }
-
-  private async loadView(manager: EntityManager, targetId: string): Promise<SurveyExecutionView> {
-    const [context] = (await manager.query(`
-      SELECT
-        JSONB_BUILD_OBJECT(
-          'id', target.id,
-          'status', target.status,
-          'dueAt', target.due_at,
-          'instructions', target.instructions,
-          'assignedUser', CASE WHEN assignee.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-            'id', assignee.id,
-            'username', assignee.username,
-            'firstName', assignee.first_name,
-            'lastName', assignee.last_name
-          ) END
-        ) AS target,
-        JSONB_BUILD_OBJECT(
-          'id', campaign.id,
-          'code', campaign.code,
-          'name', campaign.name,
-          'status', campaign.status
-        ) AS campaign,
-        JSONB_BUILD_OBJECT(
-          'id', asset.id,
-          'code', asset.code,
-          'name', asset.name,
-          'typeName', asset_type.name,
-          'informationStatus', asset.information_status,
-          'currentVersion', asset.current_version
-        ) AS asset
-      FROM survey_campaign_targets target
-      INNER JOIN survey_campaigns campaign ON campaign.id = target.campaign_id
-      INNER JOIN assets asset ON asset.id = target.asset_id
-      INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
-      LEFT JOIN users assignee ON assignee.id = target.assigned_user_id
-      WHERE target.id = $1
-    `, [targetId])) as ExecutionContextView[];
-    if (!context) throw targetNotFound();
-
-    const [report] = (await manager.query(`
-      SELECT
-        report.id,
-        report.target_id AS "targetId",
-        report.outcome,
-        report.status,
-        report.observed_at AS "observedAt",
-        report.latitude::double precision AS latitude,
-        report.longitude::double precision AS longitude,
-        report.accuracy_m::double precision AS "accuracyM",
-        report.notes,
-        report.asset_version_at_submission AS "assetVersionAtSubmission",
-        report.submitted_at AS "submittedAt",
-        CASE WHEN submitter.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', submitter.id,
-          'username', submitter.username,
-          'firstName', submitter.first_name,
-          'lastName', submitter.last_name
-        ) END AS "submittedBy",
-        report.reviewed_at AS "reviewedAt",
-        CASE WHEN reviewer.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', reviewer.id,
-          'username', reviewer.username,
-          'firstName', reviewer.first_name,
-          'lastName', reviewer.last_name
-        ) END AS "reviewedBy",
-        report.review_notes AS "reviewNotes",
-        COALESCE((
-          SELECT ARRAY_AGG(link.media_id ORDER BY link.created_at)
-          FROM survey_target_report_media link
-          INNER JOIN asset_media media ON media.id = link.media_id
-          WHERE link.report_id = report.id
-            AND link.included = true
-            AND media.deleted_at IS NULL
-        ), ARRAY[]::uuid[]) AS "selectedMediaIds",
-        report.created_at AS "createdAt",
-        report.updated_at AS "updatedAt"
-      FROM survey_target_reports report
-      LEFT JOIN users submitter ON submitter.id = report.submitted_by
-      LEFT JOIN users reviewer ON reviewer.id = report.reviewed_by
-      WHERE report.target_id = $1
-    `, [targetId])) as SurveyReportView[];
-
-    const availableMedia = (await manager.query(`
-      SELECT
-        media.id,
-        media.kind,
-        media.original_name AS "originalName",
-        media.mime_type AS "mimeType",
-        media.size_bytes::double precision AS "sizeBytes",
-        media.sha256,
-        media.title,
-        media.description,
-        media.captured_at AS "capturedAt",
-        media.latitude::double precision AS latitude,
-        media.longitude::double precision AS longitude,
-        media.accuracy_m::double precision AS "accuracyM",
-        media.source,
-        media.created_at AS "createdAt",
-        EXISTS (
-          SELECT 1 FROM survey_target_report_media link
-          WHERE link.report_id = $2 AND link.media_id = media.id AND link.included = true
-        ) AS selected
-      FROM asset_media media
-      WHERE media.asset_id = $1
-        AND media.kind = 'PHOTO'
-        AND media.deleted_at IS NULL
-      ORDER BY media.created_at DESC
-    `, [context.asset.id, report?.id ?? null])) as ReportMediaView[];
-
-    const versions = report
-      ? (await manager.query(`
-          SELECT
-            version.id,
-            version.version_number AS "versionNumber",
-            version.event,
-            version.snapshot,
-            version.actor_user_id AS "actorUserId",
-            version.actor_username AS "actorUsername",
-            version.created_at AS "createdAt"
-          FROM survey_target_report_versions version
-          WHERE version.report_id = $1
-          ORDER BY version.version_number DESC
-        `, [report.id])) as ReportVersionView[]
-      : [];
-    return { ...context, report: report ?? null, availableMedia, versions };
-  }
-
-  private async lockTargetContext(
-    manager: EntityManager,
-    targetId: string,
-  ): Promise<{ target: SurveyCampaignTarget; campaign: SurveyCampaign }> {
-    const target = await manager.getRepository(SurveyCampaignTarget)
-      .createQueryBuilder('target')
-      .where('target.id = :targetId', { targetId })
-      .setLock('pessimistic_write')
-      .getOne();
-    if (!target) throw targetNotFound();
-    const campaign = await manager.getRepository(SurveyCampaign)
-      .createQueryBuilder('campaign')
-      .where('campaign.id = :campaignId', { campaignId: target.campaignId })
-      .setLock('pessimistic_write')
-      .getOne();
-    if (!campaign) throw targetNotFound();
-    return { target, campaign };
-  }
-
-  private async lockReport(
-    manager: EntityManager,
-    targetId: string,
-    required: boolean,
-  ): Promise<SurveyTargetReport | null> {
-    const report = await manager.getRepository(SurveyTargetReport)
-      .createQueryBuilder('report')
-      .where('report.targetId = :targetId', { targetId })
-      .setLock('pessimistic_write')
-      .getOne();
-    if (!report && required) throw reportNotFound();
-    return report;
-  }
-
-  private async lockAsset(manager: EntityManager, assetId: string): Promise<Asset> {
-    const asset = await manager.getRepository(Asset)
-      .createQueryBuilder('asset')
-      .where('asset.id = :assetId', { assetId })
-      .setLock('pessimistic_write')
-      .getOne();
-    if (!asset) throw targetNotFound();
-    return asset;
-  }
-
-  private assertCaptureAllowed(
-    target: SurveyCampaignTarget,
-    campaign: SurveyCampaign,
-    principal: AuthPrincipal,
-  ): void {
-    if (campaign.status !== SurveyCampaignStatus.IN_PROGRESS) {
-      throw new ConflictException({
-        code: 'SURVEY_CAMPAIGN_NOT_IN_PROGRESS',
-        message: 'La campaña debe estar en curso para capturar el relevamiento',
-      });
-    }
-    if (target.status !== SurveyTargetStatus.IN_PROGRESS) {
-      throw new ConflictException({
-        code: 'SURVEY_TARGET_NOT_IN_PROGRESS',
-        message: 'El objetivo debe estar en ejecución para editar o enviar el informe',
-      });
-    }
-    if (
-      !principal.permissions.includes('surveys.manage') &&
-      target.assignedUserId !== principal.userId
-    ) {
-      throw new ForbiddenException({
-        code: 'SURVEY_TARGET_NOT_ASSIGNED',
-        message: 'El objetivo no está asignado al usuario actual',
-      });
-    }
-  }
-
-  private assertCoordinatePair(
-    latitude: number | null | undefined,
-    longitude: number | null | undefined,
-    accuracyM: number | null | undefined,
-  ): void {
-    if ((latitude == null) !== (longitude == null)) {
-      throw new BadRequestException({
-        code: 'SURVEY_COORDINATES_INCOMPLETE',
-        message: 'Latitud y longitud deben informarse juntas',
-      });
-    }
-    if (accuracyM != null && latitude == null) {
-      throw new BadRequestException({
-        code: 'SURVEY_ACCURACY_WITHOUT_LOCATION',
-        message: 'La precisión requiere coordenadas GPS',
-      });
-    }
-  }
-
-  private async validateMedia(
-    manager: EntityManager,
-    assetId: string,
-    mediaIds: string[],
-  ): Promise<void> {
-    if (mediaIds.length === 0) return;
-    const [row] = (await manager.query(`
-      SELECT COUNT(*)::integer AS count
-      FROM asset_media
-      WHERE asset_id = $1
-        AND id = ANY($2::uuid[])
-        AND kind = 'PHOTO'
-        AND deleted_at IS NULL
-    `, [assetId, mediaIds])) as Array<{ count: number }>;
-    if (Number(row?.count ?? 0) !== mediaIds.length) {
-      throw new BadRequestException({
-        code: 'SURVEY_MEDIA_INVALID',
-        message: 'Una o más evidencias no son fotografías activas del activo relevado',
-      });
-    }
-  }
-
-  private async replaceMediaSelection(
-    manager: EntityManager,
-    reportId: string,
-    mediaIds: string[],
-    userId: string,
-  ): Promise<void> {
-    await manager.query(`
-      UPDATE survey_target_report_media
-      SET included = false, updated_at = CURRENT_TIMESTAMP
-      WHERE report_id = $1 AND included = true
-    `, [reportId]);
-    for (const mediaId of mediaIds) {
-      await manager.query(`
-        INSERT INTO survey_target_report_media (
-          report_id, media_id, included, added_by
-        ) VALUES ($1, $2, true, $3)
-        ON CONFLICT (report_id, media_id) DO UPDATE SET
-          included = true,
-          added_by = EXCLUDED.added_by,
-          updated_at = CURRENT_TIMESTAMP
-      `, [reportId, mediaId, userId]);
-    }
-  }
-
-  private async assertComplete(
-    manager: EntityManager,
-    report: SurveyTargetReport,
-  ): Promise<void> {
-    if (!report.outcome) {
-      throw new BadRequestException({
-        code: 'SURVEY_OUTCOME_REQUIRED',
-        message: 'Seleccioná el resultado de la verificación',
-      });
-    }
-    if (!report.observedAt) {
-      throw new BadRequestException({
-        code: 'SURVEY_OBSERVED_AT_REQUIRED',
-        message: 'Indicá la fecha y hora de observación',
-      });
-    }
-    if (report.latitude == null || report.longitude == null || report.accuracyM == null) {
-      throw new BadRequestException({
-        code: 'SURVEY_GPS_REQUIRED',
-        message: 'Capturá ubicación y precisión GPS antes de enviar',
-      });
-    }
-    if (
-      report.outcome !== SurveyReportOutcome.CONFIRMED &&
-      (!report.notes || report.notes.trim().length < 10)
-    ) {
-      throw new BadRequestException({
-        code: 'SURVEY_NOTES_REQUIRED',
-        message: 'Describí los cambios o la imposibilidad de localizar el activo',
-      });
-    }
-    const [row] = (await manager.query(`
-      SELECT COUNT(*)::integer AS count
-      FROM survey_target_report_media link
-      INNER JOIN asset_media media ON media.id = link.media_id
-      WHERE link.report_id = $1
-        AND link.included = true
-        AND media.kind = 'PHOTO'
-        AND media.deleted_at IS NULL
-    `, [report.id])) as Array<{ count: number }>;
-    if (Number(row?.count ?? 0) < 1) {
-      throw new BadRequestException({
-        code: 'SURVEY_PHOTO_REQUIRED',
-        message: 'Seleccioná al menos una fotografía como evidencia',
-      });
-    }
-  }
-
-  private async captureReportVersion(
-    manager: EntityManager,
-    report: SurveyTargetReport,
-    event: SurveyReportVersionEvent,
-    principal: AuthPrincipal,
-  ): Promise<number> {
-    const [row] = (await manager.query(`
-      SELECT COALESCE(MAX(version_number), 0)::integer + 1 AS "versionNumber"
-      FROM survey_target_report_versions
-      WHERE report_id = $1
-    `, [report.id])) as Array<{ versionNumber: number }>;
-    const versionNumber = Number(row?.versionNumber ?? 1);
-    const snapshot = await this.buildReportSnapshot(manager, report.id);
-    await manager.query(`
-      INSERT INTO survey_target_report_versions (
-        report_id, version_number, event, snapshot, actor_user_id, actor_username
-      ) VALUES ($1, $2, $3, $4, $5, $6)
-    `, [report.id, versionNumber, event, snapshot, principal.userId, principal.username]);
-    return versionNumber;
-  }
-
-  private async buildReportSnapshot(
-    manager: EntityManager,
-    reportId: string,
-  ): Promise<Record<string, unknown>> {
-    const [row] = (await manager.query(`
-      SELECT JSONB_BUILD_OBJECT(
-        'id', report.id,
-        'status', report.status,
-        'outcome', report.outcome,
-        'observedAt', report.observed_at,
-        'location', JSONB_BUILD_OBJECT(
-          'latitude', report.latitude,
-          'longitude', report.longitude,
-          'accuracyM', report.accuracy_m
-        ),
-        'notes', report.notes,
-        'assetVersionAtSubmission', report.asset_version_at_submission,
-        'submittedAt', report.submitted_at,
-        'submittedBy', report.submitted_by,
-        'reviewedAt', report.reviewed_at,
-        'reviewedBy', report.reviewed_by,
-        'reviewNotes', report.review_notes,
-        'target', JSONB_BUILD_OBJECT(
-          'id', target.id,
-          'status', target.status,
-          'dueAt', target.due_at,
-          'instructions', target.instructions
-        ),
-        'campaign', JSONB_BUILD_OBJECT(
-          'id', campaign.id,
-          'code', campaign.code,
-          'name', campaign.name
-        ),
-        'asset', JSONB_BUILD_OBJECT(
-          'id', asset.id,
-          'code', asset.code,
-          'name', asset.name,
-          'informationStatus', asset.information_status,
-          'currentVersion', asset.current_version
-        ),
-        'evidence', COALESCE((
-          SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
-            'id', media.id,
-            'originalName', media.original_name,
-            'mimeType', media.mime_type,
-            'sizeBytes', media.size_bytes,
-            'sha256', media.sha256,
-            'title', media.title,
-            'description', media.description,
-            'capturedAt', media.captured_at,
-            'latitude', media.latitude,
-            'longitude', media.longitude,
-            'accuracyM', media.accuracy_m,
-            'source', media.source,
-            'createdAt', media.created_at
-          ) ORDER BY media.created_at, media.id)
-          FROM survey_target_report_media link
-          INNER JOIN asset_media media ON media.id = link.media_id
-          WHERE link.report_id = report.id AND link.included = true
-        ), '[]'::jsonb)
-      ) AS snapshot
-      FROM survey_target_reports report
-      INNER JOIN survey_campaign_targets target ON target.id = report.target_id
-      INNER JOIN survey_campaigns campaign ON campaign.id = target.campaign_id
-      INNER JOIN assets asset ON asset.id = target.asset_id
-      WHERE report.id = $1
-    `, [reportId])) as Array<{ snapshot: Record<string, unknown> }>;
-    if (!row) throw reportNotFound();
-    return row.snapshot;
-  }
-
-  private async recordAssetChange(
-    manager: EntityManager,
-    asset: Asset,
-    beforeData: Record<string, unknown>,
-    action: AuditAction,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-    targetId: string,
-    versionNumber: number,
-  ): Promise<void> {
-    await this.audit.record({
-      ...administrationAuditContext(principal, request),
-      action,
-      entityType: 'asset',
-      entityId: asset.id,
-      beforeData,
-      afterData: this.assetAuditView(asset),
-      metadata: { targetId, versionNumber, source: 'survey_report' },
-    }, manager);
-  }
-
-  private assetAuditView(asset: Asset): Record<string, unknown> {
-    return {
-      informationStatus: asset.informationStatus,
-      dataOrigin: asset.dataOrigin,
-      sourceName: asset.sourceName,
-      sourceReference: asset.sourceReference,
-      sourceObservedAt: asset.sourceObservedAt,
-      provenanceVerifiedAt: asset.provenanceVerifiedAt,
-      provenanceVerifiedBy: asset.provenanceVerifiedBy,
-      currentVersion: asset.currentVersion,
-    };
-  }
-
-  private reportAuditView(report: SurveyTargetReport): Record<string, unknown> {
-    return {
-      targetId: report.targetId,
-      outcome: report.outcome,
-      status: report.status,
-      observedAt: report.observedAt,
-      latitude: this.numberOrNull(report.latitude),
-      longitude: this.numberOrNull(report.longitude),
-      accuracyM: this.numberOrNull(report.accuracyM),
-      notes: report.notes,
-      assetVersionAtSubmission: report.assetVersionAtSubmission,
-      submittedAt: report.submittedAt,
-      submittedBy: report.submittedBy,
-      reviewedAt: report.reviewedAt,
-      reviewedBy: report.reviewedBy,
-      reviewNotes: report.reviewNotes,
-    };
-  }
-
-  private numberOrNull(value: string | number | null): number | null {
-    return value == null ? null : Number(value);
-  }
-}

From fbf426ed90891df80cddf786c1f33ab1bd994826 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:27:24 -0300
Subject: [PATCH 127/224] F4: remove legacy survey review DTO

---
 .../dto/review-survey-report.dto.ts              | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 api-v3/src/survey-execution/dto/review-survey-report.dto.ts

diff --git a/api-v3/src/survey-execution/dto/review-survey-report.dto.ts b/api-v3/src/survey-execution/dto/review-survey-report.dto.ts
deleted file mode 100644
index cf878fb..0000000
--- a/api-v3/src/survey-execution/dto/review-survey-report.dto.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { IsEnum, IsOptional, IsString, MaxLength } from 'class-validator';
-
-export enum SurveyReviewDecision {
-  APPROVE = 'APPROVE',
-  REJECT = 'REJECT',
-}
-
-export class ReviewSurveyReportDto {
-  @IsEnum(SurveyReviewDecision)
-  decision!: SurveyReviewDecision;
-
-  @IsOptional()
-  @IsString()
-  @MaxLength(4000)
-  notes?: string | null;
-}

From 068cf8ae3a75185b50c80de1a6525599e3427087 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:27:35 -0300
Subject: [PATCH 128/224] F4: remove legacy survey report DTO

---
 .../dto/save-survey-report.dto.ts             | 58 -------------------
 1 file changed, 58 deletions(-)
 delete mode 100644 api-v3/src/survey-execution/dto/save-survey-report.dto.ts

diff --git a/api-v3/src/survey-execution/dto/save-survey-report.dto.ts b/api-v3/src/survey-execution/dto/save-survey-report.dto.ts
deleted file mode 100644
index 74f1cb0..0000000
--- a/api-v3/src/survey-execution/dto/save-survey-report.dto.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { Type } from 'class-transformer';
-import {
-  ArrayMaxSize,
-  ArrayUnique,
-  IsArray,
-  IsEnum,
-  IsISO8601,
-  IsNumber,
-  IsOptional,
-  IsString,
-  IsUUID,
-  Max,
-  MaxLength,
-  Min,
-} from 'class-validator';
-import { SurveyReportOutcome } from '../../database/entities';
-
-export class SaveSurveyReportDto {
-  @IsOptional()
-  @IsEnum(SurveyReportOutcome)
-  outcome?: SurveyReportOutcome | null;
-
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  observedAt?: string | null;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-90)
-  @Max(90)
-  latitude?: number | null;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-180)
-  @Max(180)
-  longitude?: number | null;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 3 })
-  @Min(0)
-  @Max(100000)
-  accuracyM?: number | null;
-
-  @IsOptional()
-  @IsString()
-  @MaxLength(8000)
-  notes?: string | null;
-
-  @IsArray()
-  @ArrayMaxSize(50)
-  @ArrayUnique()
-  @IsUUID('4', { each: true })
-  mediaIds!: string[];
-}

From c2c935fd858b654dbb17d766875d10435d757441 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:28:08 -0300
Subject: [PATCH 129/224] noop

---
 web-v2/src/lib/api.ts | 3132 +----------------------------------------
 1 file changed, 1 insertion(+), 3131 deletions(-)

diff --git a/web-v2/src/lib/api.ts b/web-v2/src/lib/api.ts
index d4885d2..b3a4252 100644
--- a/web-v2/src/lib/api.ts
+++ b/web-v2/src/lib/api.ts
@@ -1,3131 +1 @@
-const API_BASE = '/api/v3';
-
-export class ApiError extends Error {
-  constructor(
-    public readonly status: number,
-    public readonly code: string,
-    message: string,
-    public readonly requestId?: string,
-  ) {
-    super(message);
-    this.name = 'ApiError';
-  }
-}
-
-export interface AuthUser {
-  id: string;
-  username: string;
-  firstName: string;
-  lastName: string;
-  email: string | null;
-  mustChangePassword: boolean;
-  roles: string[];
-  permissions: string[];
-}
-
-export interface AuthResponse {
-  user: AuthUser;
-  csrfToken: string;
-  accessExpiresInSeconds: number;
-}
-
-export interface HealthResponse {
-  status: string;
-  service: string;
-  api: string;
-  version: string;
-  phase: string;
-  database: string;
-  time: string;
-  latencyMs: number;
-}
-
-export interface DashboardSummary {
-  counts: {
-    totalAssets: number;
-    assetsNeedValidation: number;
-    assetsWithoutGeometry: number;
-    plannedInspections: number;
-    activeUsers: number;
-    inactiveUsers: number;
-    activeSessions: number;
-    openFindings: number;
-    awaitingCompanyResponse: number;
-    overdueCompanyResponses: number;
-    companyResponsesDueNext7Days: number;
-    awaitingVerificationSchedule: number;
-    overdueControls: number;
-    controlsNext30Days: number;
-  };
-  recentAudit: Array<{
-    id: string;
-    occurredAt: string;
-    actorUsername: string | null;
-    action: string;
-    entityType: string | null;
-    entityId: string | null;
-  }>;
-  upcomingControls: Array<{
-    id: string;
-    code: string;
-    title: string;
-    nextControlOn: string;
-    actId: string;
-    actCode: string;
-    visitId: string;
-    visitCode: string;
-    assetId: string;
-    assetCode: string;
-    assetName: string;
-  }>;
-  generatedAt: string;
-}
-
-export interface RoleSummary { id: string; code: string; name: string }
-
-export interface AdministrativeUser {
-  id: string;
-  username: string;
-  email: string | null;
-  firstName: string;
-  lastName: string;
-  status: 'ACTIVE' | 'INACTIVE';
-  mustChangePassword: boolean;
-  failedLoginAttempts: number;
-  lockedUntil: string | null;
-  lastLoginAt: string | null;
-  passwordChangedAt: string | null;
-  createdAt: string;
-  updatedAt: string;
-  roles: RoleSummary[];
-}
-
-export interface Permission { id: string; code: string; description: string }
-
-export interface AdministrativeRole {
-  id: string;
-  code: string;
-  name: string;
-  description: string;
-  isSystem: boolean;
-  createdAt: string;
-  updatedAt: string;
-  userCount: number;
-  permissions: Permission[];
-}
-
-export interface AuditEventSummary {
-  id: string;
-  occurredAt: string;
-  actorUserId: string | null;
-  actorUsername: string | null;
-  action: string;
-  entityType: string | null;
-  entityId: string | null;
-  requestId: string | null;
-  source: 'WEB' | 'ANDROID' | 'SYSTEM' | 'IMPORT';
-  ip: string | null;
-  hasDetails: boolean;
-}
-
-export interface AuditEventDetail extends AuditEventSummary {
-  userAgent: string | null;
-  beforeData: Record<string, unknown> | null;
-  afterData: Record<string, unknown> | null;
-  metadata: Record<string, unknown> | null;
-}
-
-export interface PageMeta { page: number; pageSize: number; total: number; totalPages: number }
-interface Page<T> { data: T[]; meta: PageMeta }
-
-export type AssetInformationStatus =
-  | 'DRAFT' | 'PENDING_SURVEY' | 'SURVEYED' | 'VALIDATED'
-  | 'OBSERVED' | 'OUTDATED' | 'INACTIVE';
-
-export type AssetOperationalStatus =
-  | 'UNKNOWN' | 'IN_SERVICE' | 'TEMPORARILY_OUT_OF_SERVICE'
-  | 'OUT_OF_SERVICE' | 'DECOMMISSIONED' | 'ABANDONED';
-
-export type AssetDataOrigin =
-  | 'MANUAL' | 'FIELD_SURVEY' | 'PROVIDED_DOCUMENT' | 'IMPORT' | 'SYSTEM';
-
-export type AssetTypeOperationalRole = 'GENERIC' | 'AREA' | 'COMPANY';
-
-export interface AssetProvenance {
-  assetId: string;
-  origin: AssetDataOrigin;
-  sourceName: string | null;
-  sourceReference: string | null;
-  observedAt: string | null;
-  notes: string | null;
-  verifiedAt: string | null;
-  verifiedBy: string | null;
-  verifiedByUsername: string | null;
-  updatedAt: string;
-  updatedBy: string | null;
-  updatedByUsername: string | null;
-}
-
-export type AssetAttributeDataType =
-  | 'TEXT' | 'NUMBER' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'SELECT';
-
-export interface AssetAttributeDefinition {
-  id: string;
-  code: string;
-  name: string;
-  dataType: AssetAttributeDataType;
-  isRequired: boolean;
-  isActive: boolean;
-  unit: string | null;
-  options: string[] | null;
-  sortOrder: number;
-}
-
-export interface AssetTypeSummary {
-  id: string;
-  code: string;
-  name: string;
-  isActive: boolean;
-  operationalRole: AssetTypeOperationalRole;
-}
-
-export interface AssetType extends AssetTypeSummary {
-  description: string;
-  canBeRoot: boolean;
-  createdAt: string;
-  updatedAt: string;
-  assetCount: number;
-  allowedParentTypes: AssetTypeSummary[];
-  attributes: AssetAttributeDefinition[];
-}
-
-export interface MasterBootstrapStatus {
-  presetCode: string;
-  presetName: string;
-  typeCount: number;
-  canApply: boolean;
-  reason: string | null;
-  types: Array<{
-    code: string;
-    name: string;
-    operationalRole: AssetTypeOperationalRole;
-    parentCodes: string[];
-    attributeCount: number;
-  }>;
-}
-
-export interface MasterBootstrapResult {
-  presetCode: string;
-  presetName: string;
-  createdTypeCount: number;
-  createdAttributeCount: number;
-  createdParentRuleCount: number;
-  data: AssetType[];
-}
-
-export interface MasterEnrichmentStatus {
-  presetCode: string;
-  presetName: string;
-  typeCount: number;
-  canApply: boolean;
-  complete: boolean;
-  reason: string | null;
-  missingTypeCodes: string[];
-  missingAttributeCount: number;
-  missingParentRuleCount: number;
-}
-
-export interface AssetListItem {
-  id: string;
-  code: string;
-  name: string;
-  commonName: string | null;
-  type: { id: string; code: string; name: string };
-  parent: { id: string; code: string; name: string } | null;
-  operationalArea: { id: string; code: string; name: string } | null;
-  operatorCompany: { id: string; code: string; name: string } | null;
-  informationStatus: AssetInformationStatus;
-  operationalStatus: AssetOperationalStatus;
-  childrenCount: number;
-  hasGeometry: boolean;
-  geometryType: AssetGeometryType | null;
-  mediaCount: number;
-  dataOrigin: AssetDataOrigin;
-  provenanceVerified: boolean;
-  currentVersion: number;
-  updatedAt: string;
-}
-
-export interface AssetLineageItem {
-  id: string;
-  code: string;
-  name: string;
-  commonName: string | null;
-  type: { id: string; code: string; name: string };
-}
-
-export interface AssetDetail extends AssetListItem {
-  description: string | null;
-  createdAt: string;
-  createdBy: string | null;
-  updatedBy: string | null;
-  attributes: Array<{
-    definitionId: string;
-    code: string;
-    name: string;
-    dataType: AssetAttributeDataType;
-    isRequired: boolean;
-    unit: string | null;
-    options: string[] | null;
-    sortOrder: number;
-    value: unknown;
-  }>;
-}
-
-export type AssetDossierTimelineKind =
-  | 'INVENTORY_CHANGE' | 'INSPECTION' | 'ACT' | 'FINDING' | 'FINDING_CLOSED'
-  | 'COMMUNICATION' | 'PHOTO' | 'DOCUMENT' | 'REPORT' | 'SOURCE_DOCUMENT' | 'VERIFICATION';
-
-export interface AssetDossierTimelineEvent {
-  id: string;
-  kind: AssetDossierTimelineKind;
-  occurredAt: string;
-  title: string;
-  description: string | null;
-  href?: string;
-  meta?: Record<string, unknown>;
-}
-
-export interface AssetDossier {
-  asset: { id: string; code: string; name: string; commonName: string | null };
-  counters: {
-    inspections: number; acts: number; findings: number; openFindings: number; closedFindings: number;
-    evidence: number; documents: number; photos: number; reports: number; verifications: number;
-  };
-  visits: Array<{ id: string; code: string; title: string; status: InspectionVisitStatus; plannedStartAt: string | null; actualStartedAt: string | null; actualClosedAt: string | null; createdAt: string }>;
-  acts: Array<{ id: string; visitId: string; code: string; status: InspectionActStatus; occurredAt: string; title: string; summary: string; closedAt: string | null; currentVersion: number; visitCode: string; visitTitle: string }>;
-  findings: Array<{ id: string; actId: string; code: string; status: InspectionFindingStatus; title: string; description: string; correctionDueOn: string | null; companyResponseReceivedOn: string | null; nextControlOn: string | null; closedAt: string | null; closureNotes: string | null; createdAt: string; updatedAt: string; actCode: string; actOccurredAt: string; visitId: string; visitCode: string; visitTitle: string }>;
-  evidence: Array<{ id: string; findingId: string; communicationId: string | null; kind: InspectionEvidenceKind; purpose: InspectionEvidencePurpose; originalName: string; title: string | null; description: string | null; capturedAt: string | null; createdAt: string; findingCode: string; findingTitle: string }>;
-  communications: Array<{ id: string; findingId: string; direction: InspectionFindingCommunication['direction']; channel: InspectionFindingCommunication['channel']; type: InspectionFindingCommunication['type']; occurredAt: string; subject: string; details: string | null; contactName: string | null; createdAt: string; findingCode: string; findingTitle: string }>;
-  verificationResults: Array<{ id: string; findingId: string; findingCode: string; findingTitle: string; visitId: string; visitCode: string; visitTitle: string; visitStatus: InspectionVisitStatus; targetControlOn: string | null; outcome: InspectionVerificationOutcome | null; resultNotes: string | null; verifiedAt: string | null; resultRecordedAt: string | null; rescheduledControlOn: string | null; evidenceCount: number }>;
-  documents: Array<{ id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string; issuer: string | null; documentDate: string | null; externalReference: string | null; relationType: AssetSourceDocumentRelationType; notes: string | null; linkedAt: string }>;
-  inspectionReports: Array<{ id: string; code: string; status: InspectionReportStatus; pdfStatus: InspectionReportPdfStatus; title: string; generatedAt: string; frozenSha256: string; actId: string; actCode: string; visitId: string; visitCode: string }>;
-  reports: Array<{ id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string; issuer: string | null; documentDate: string | null; externalReference: string | null; relationType: AssetSourceDocumentRelationType; notes: string | null; linkedAt: string }>;
-  media: Array<{ id: string; kind: AssetMediaKind; originalName: string; title: string | null; description: string | null; capturedAt: string | null; createdAt: string; source: 'WEB' | 'ANDROID' | 'IMPORT' }>;
-  versions: Array<{ id: string; versionNumber: number; changeType: AssetVersionChangeType; changedFields: string[]; occurredAt: string; actorUsername: string | null; source: string }>;
-  timeline: AssetDossierTimelineEvent[];
-}
-
-export interface AssetContextHistoryItem {
-  id: string;
-  assetId: string;
-  validFrom: string;
-  validUntil: string | null;
-  changeReason: string;
-  endReason: string | null;
-  assetVersionNumber: number;
-  source: string;
-  requestId: string | null;
-  createdAt: string;
-  parent: { id: string; code: string; name: string } | null;
-  operationalArea: { id: string; code: string; name: string } | null;
-  operatorCompany: { id: string; code: string; name: string } | null;
-  creator: { id: string; username: string; firstName: string; lastName: string } | null;
-  isCurrent: boolean;
-}
-
-export type FieldDiscoveryStatus = 'PENDING' | 'APPROVED' | 'MATCHED' | 'REJECTED';
-
-export interface FieldDiscovery {
-  id: string;
-  status: FieldDiscoveryStatus;
-  discoveryNotes: string | null;
-  observedAt: string;
-  reviewedAt: string | null;
-  reviewNotes: string | null;
-  createdAt: string;
-  asset: {
-    id: string; code: string; name: string; commonName: string | null; informationStatus: AssetInformationStatus;
-    typeId: string; typeName: string; parentId: string | null; operationalAreaId: string | null; operatorCompanyId: string | null;
-  };
-  visit: { id: string; code: string; title: string; status: InspectionVisitStatus };
-  creator: { id: string; username: string; firstName: string; lastName: string };
-  reviewer: { id: string; username: string; firstName: string; lastName: string } | null;
-  matchedAsset: { id: string; code: string; name: string; commonName: string | null } | null;
-}
-
-export interface OperationalAssetSummary {
-  id: string;
-  code: string;
-  name: string;
-  commonName: string | null;
-  typeName: string;
-}
-
-export type AreaOrganizationRole = 'OPERATOR' | 'TECHNICAL_OPERATOR' | 'CONCESSIONAIRE' | 'PERMIT_HOLDER' | 'PARTICIPANT' | 'OTHER';
-
-export interface AreaCompanyRelation {
-  id: string;
-  area: OperationalAssetSummary;
-  company: OperationalAssetSummary;
-  relationRole: AreaOrganizationRole;
-  participationPercent: number | null;
-  legalInstrument: string | null;
-  sourceDocumentId: string | null;
-  validFrom: string;
-  validUntil: string | null;
-  startReason: string;
-  endReason: string | null;
-  createdBy: { id: string; username: string } | null;
-  endedBy: { id: string; username: string } | null;
-  createdAt: string;
-  updatedAt: string;
-  active: boolean;
-  assignedAssetCount: number;
-}
-
-
-export type OrganizationKind = 'COMPANY' | 'UTE' | 'PUBLIC_ENTITY' | 'OTHER';
-export type SourceDocumentType = 'NOTE' | 'TECHNICAL_REPORT' | 'INSPECTION_ACT' | 'INVENTORY' | 'RESOLUTION' | 'DECREE' | 'CONTRACT' | 'SPREADSHEET' | 'OTHER';
-export type AssetSourceDocumentRelationType = 'SOURCE' | 'MENTIONS' | 'VALIDATES' | 'SUPERSEDES' | 'OTHER';
-export type OrganizationMembershipRole = 'MEMBER' | 'LEAD_MEMBER' | 'OTHER';
-export type AreaLegalRightType = 'EXPLOITATION_CONCESSION' | 'EXPLORATION_PERMIT' | 'TRANSPORT_CONCESSION' | 'OTHER';
-export type AreaLegalRightStatus = 'ACTIVE' | 'EXPIRED' | 'REVOKED' | 'PENDING';
-export type AreaLegalRightOrganizationRole = 'HOLDER' | 'PARTICIPANT' | 'OPERATOR' | 'OTHER';
-
-export interface SourceDocumentSummary {
-  id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string;
-  issuer: string | null; documentDate: string | null; externalReference: string | null; notes: string | null;
-  createdAt?: string; updatedAt?: string;
-}
-export interface AssetRegistry {
-  organizationProfile: null | { assetId: string; organizationKind: OrganizationKind; legalName: string | null; taxId: string | null; notificationEmail: string | null; notes: string | null; createdAt: string; updatedAt: string };
-  organizationMemberships: Array<{ id: string; parent: { id: string; code: string; name: string }; member: { id: string; code: string; name: string }; role: OrganizationMembershipRole; participationPercent: number | null; validFrom: string; validUntil: string | null; sourceDocumentId: string | null; notes: string | null; endReason: string | null }>;
-  externalIdentifiers: Array<{ id: string; namespace: string; value: string; validFrom: string; validUntil: string | null; sourceDocumentId: string | null; notes: string | null; endReason: string | null }>;
-  sourceDocuments: Array<SourceDocumentSummary & { linkId: string; relationType: AssetSourceDocumentRelationType; linkNotes: string | null }>;
-  legalRights: Array<{ id: string; rightType: AreaLegalRightType; name: string; instrumentNumber: string | null; validFrom: string | null; validUntil: string | null; status: AreaLegalRightStatus; sourceDocumentId: string | null; notes: string | null; organizations: Array<{ id: string; organizationId: string; organizationName: string; role: AreaLegalRightOrganizationRole; participationPercent: number | null; validFrom: string; validUntil: string | null; notes: string | null; endReason: string | null }> }>;
-}
-
-
-export type AssetImportBatchStatus = 'ANALYZED' | 'REVIEW_REQUIRED' | 'CANCELLED' | 'FAILED';
-export type AssetImportRowStatus = 'READY' | 'WARNING' | 'CONFLICT' | 'IGNORED';
-export type AssetImportProfileCode = 'MENDOZA_INVENTORY_V1' | 'MENDOZA_YACIMIENTOS_V1' | 'UNKNOWN';
-
-export interface AssetImportBatch {
-  id: string;
-  originalName: string;
-  mimeType: string;
-  sizeBytes: number;
-  sha256: string;
-  profileCode: AssetImportProfileCode;
-  profileConfidence: number;
-  worksheetName: string | null;
-  headerRow: number | null;
-  totalRows: number;
-  readyRows: number;
-  warningRows: number;
-  conflictRows: number;
-  ignoredRows: number;
-  status: AssetImportBatchStatus;
-  sourceDocumentId: string | null;
-  sourceLabel: string | null;
-  notes: string | null;
-  analysis: Record<string, unknown>;
-  uploadedBy: string | null;
-  uploadedByUsername: string | null;
-  analyzedAt: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface AssetImportBatchDetail extends AssetImportBatch {
-  topIssues: Array<{ code: string; count: number }>;
-  duplicateFiles: Array<{ id: string; originalName: string; createdAt: string; status: AssetImportBatchStatus }>;
-}
-
-export interface AssetImportRow {
-  id: string;
-  worksheetName: string;
-  rowNumber: number;
-  status: AssetImportRowStatus;
-  suggestedAction: 'CREATE' | 'MATCH' | 'REVIEW' | 'IGNORE';
-  rawData: Record<string, unknown>;
-  normalizedData: Record<string, unknown>;
-  issues: string[];
-  fingerprint: string;
-  matchedAssetId: string | null;
-  importedAssetId: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export type AssetImportPlanStatus = 'REVIEW_REQUIRED' | 'READY' | 'APPLIED' | 'ROLLED_BACK' | 'SUPERSEDED' | 'FAILED';
-export type AssetImportPlanEntityKind = 'DEPARTMENT' | 'ORGANIZATION' | 'AREA' | 'AREA_DEPARTMENT_RELATION' | 'FIELD' | 'OPERATOR_RELATION' | 'LEGAL_RIGHT' | 'LEGAL_RIGHT_ORGANIZATION' | 'INSTALLATION' | 'LOCAL_STRUCTURE' | 'TECHNICAL_ASSET';
-export type AssetImportPlanAction = 'CREATE' | 'MATCH' | 'REVIEW' | 'IGNORE';
-export type AssetImportPlanItemStatus = 'PLANNED' | 'MATCHED' | 'REVIEW' | 'IGNORED' | 'APPLIED' | 'ROLLED_BACK' | 'FAILED';
-
-export interface AssetImportPlanItem {
-  id: string;
-  planId: string;
-  itemOrder: number;
-  entityKey: string;
-  entityKind: AssetImportPlanEntityKind;
-  action: AssetImportPlanAction;
-  status: AssetImportPlanItemStatus;
-  assetTypeCode: string | null;
-  displayName: string;
-  generatedCode: string | null;
-  parentEntityKey: string | null;
-  matchedAssetId: string | null;
-  appliedAssetId: string | null;
-  appliedObjectId: string | null;
-  payload: Record<string, unknown>;
-  sourceRowNumbers: number[];
-  reviewCodes: string[];
-  resolutionNote: string | null;
-  resolvedBy: string | null;
-  resolvedAt: string | null;
-}
-
-export interface AssetImportPlan {
-  id: string;
-  batchId: string;
-  revision: number;
-  status: AssetImportPlanStatus;
-  externalIdNamespace: string | null;
-  operatorAssetId: string | null;
-  summary: Record<string, unknown>;
-  planHash: string;
-  generatedBy: string | null;
-  generatedAt: string;
-  appliedBy: string | null;
-  appliedAt: string | null;
-  applicationSummary: Record<string, unknown> | null;
-  rolledBackBy: string | null;
-  rolledBackAt: string | null;
-  rollbackSummary: Record<string, unknown> | null;
-  supersededAt: string | null;
-  createdAt: string;
-  updatedAt: string;
-  masterStateStale: boolean;
-  masterStateHashAvailable: boolean;
-  masterStateCheckedAt: string;
-  previewItems: AssetImportPlanItem[];
-  reviewItems: AssetImportPlanItem[];
-}
-
-export interface AssetImportReviewItem extends AssetImportPlanItem {
-  batchId: string;
-  batchName: string;
-  sourceLabel: string | null;
-  profileCode: AssetImportProfileCode;
-  planRevision: number;
-  planStatus: AssetImportPlanStatus;
-  dependency: boolean;
-}
-
-export interface AssetImportOrganizationOption {
-  id: string;
-  code: string;
-  name: string;
-  legalName: string | null;
-}
-
-export type Position = [number, number];
-export type AssetGeometryType = 'POINT' | 'LINESTRING' | 'POLYGON';
-
-export type GeoJsonGeometry =
-  | { type: 'POINT'; coordinates: Position }
-  | { type: 'LINESTRING'; coordinates: Position[] }
-  | { type: 'POLYGON'; coordinates: Position[][] };
-
-export interface AssetGeometry {
-  assetId: string;
-  geometry: GeoJsonGeometry;
-  geometryType: AssetGeometryType;
-  source: 'WEB' | 'ANDROID' | 'IMPORT' | 'SURVEY';
-  accuracyM: number | null;
-  capturedAt: string | null;
-  deviceLabel: string | null;
-  createdAt: string;
-  updatedAt: string;
-  updatedBy: string | null;
-}
-
-export interface MapAssetProperties {
-  id: string;
-  code: string;
-  name: string;
-  commonName?: string | null;
-  typeId: string;
-  typeCode: string;
-  typeName: string;
-  parentId: string | null;
-  parentName: string | null;
-  informationStatus: AssetInformationStatus;
-  geometryType: AssetGeometryType;
-  accuracyM: number | null;
-  capturedAt: string | null;
-  updatedAt: string;
-}
-
-export interface MapAssetFeature {
-  type: 'Feature';
-  id: string;
-  geometry: GeoJsonGeometry;
-  properties: MapAssetProperties;
-}
-
-export interface MapAssetFeatureCollection {
-  type: 'FeatureCollection';
-  features: MapAssetFeature[];
-  meta: { count: number; truncated: boolean };
-}
-
-export type AssetMediaKind = 'PHOTO' | 'DOCUMENT';
-
-export interface AssetMedia {
-  id: string;
-  assetId: string;
-  kind: AssetMediaKind;
-  originalName: string;
-  mimeType: 'image/jpeg' | 'image/png' | 'image/webp' | 'application/pdf';
-  sizeBytes: number;
-  sha256: string;
-  title: string | null;
-  description: string | null;
-  capturedAt: string | null;
-  latitude: number | null;
-  longitude: number | null;
-  accuracyM: number | null;
-  source: 'WEB' | 'ANDROID' | 'IMPORT';
-  uploadedBy: string | null;
-  uploadedByUsername: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export type AssetVersionChangeType =
-  | 'BASELINE'
-  | 'CREATED'
-  | 'UPDATED'
-  | 'CONTEXT_CHANGED'
-  | 'STATUS_CHANGED'
-  | 'OPERATIONAL_STATUS_CHANGED'
-  | 'REGISTRY_UPDATED'
-  | 'GEOMETRY_UPDATED'
-  | 'GEOMETRY_REMOVED'
-  | 'MEDIA_UPLOADED'
-  | 'MEDIA_UPDATED'
-  | 'MEDIA_REMOVED'
-  | 'PROVENANCE_BASELINE'
-  | 'PROVENANCE_UPDATED'
-  | 'PROVENANCE_VERIFIED';
-
-export interface AssetVersionSnapshot {
-  id: string;
-  code: string;
-  name: string;
-  description: string | null;
-  type: { id: string; code: string; name: string; operationalRole?: AssetTypeOperationalRole };
-  parent: { id: string; code: string; name: string } | null;
-  operationalArea?: { id: string; code: string; name: string } | null;
-  operatorCompany?: { id: string; code: string; name: string } | null;
-  informationStatus: AssetInformationStatus;
-  operationalStatus: AssetOperationalStatus;
-  organizationProfile?: Record<string, unknown> | null;
-  organizationMemberships?: Array<Record<string, unknown>>;
-  externalIdentifiers?: Array<Record<string, unknown>>;
-  sourceDocuments?: Array<Record<string, unknown>>;
-  legalRights?: Array<Record<string, unknown>>;
-  attributes: Array<{
-    definitionId: string;
-    code: string;
-    name: string;
-    dataType: AssetAttributeDataType;
-    isRequired: boolean;
-    unit: string | null;
-    options: string[] | null;
-    sortOrder: number;
-    value: unknown;
-  }>;
-  geometry: AssetGeometry | null;
-  media?: AssetMedia[];
-  provenance?: {
-    origin: AssetDataOrigin;
-    sourceName: string | null;
-    sourceReference: string | null;
-    observedAt: string | null;
-    notes: string | null;
-    verifiedAt: string | null;
-    verifiedBy: string | null;
-    updatedAt: string;
-    updatedBy: string | null;
-  };
-  createdAt: string;
-  updatedAt: string;
-  createdBy: string | null;
-  updatedBy: string | null;
-  currentVersion: number;
-}
-
-export interface AssetVersionSummary {
-  id: string;
-  assetId: string;
-  assetCode: string;
-  assetName: string;
-  typeId: string;
-  typeName: string;
-  informationStatus: AssetInformationStatus;
-  operationalStatus: AssetOperationalStatus;
-  versionNumber: number;
-  changeType: AssetVersionChangeType;
-  changedFields: string[];
-  occurredAt: string;
-  actorUserId: string | null;
-  actorUsername: string | null;
-  source: 'WEB' | 'ANDROID' | 'SYSTEM' | 'IMPORT';
-  requestId: string | null;
-  isCurrent: boolean;
-}
-
-export interface AssetVersionDetail extends AssetVersionSummary {
-  snapshot: AssetVersionSnapshot;
-}
-
-export interface TemporalAssetSummary extends AssetVersionSummary {
-  effectiveUntil: string | null;
-}
-
-export interface TemporalAssetDetail extends TemporalAssetSummary {
-  snapshot: AssetVersionSnapshot;
-  asOf: string;
-}
-
-export type SurveyCampaignStatus =
-  | 'DRAFT' | 'PLANNED' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED';
-
-export type SurveyTargetStatus =
-  | 'PENDING' | 'IN_PROGRESS' | 'SUBMITTED' | 'COMPLETED' | 'SKIPPED';
-
-export interface SurveyPerson {
-  id: string;
-  username: string;
-  firstName: string;
-  lastName: string;
-}
-
-export interface SurveyCampaignListItem {
-  id: string;
-  code: string;
-  name: string;
-  description: string | null;
-  status: SurveyCampaignStatus;
-  plannedStartAt: string | null;
-  plannedEndAt: string | null;
-  scopeAsset: { id: string; code: string; name: string } | null;
-  coordinator: SurveyPerson | null;
-  targetCount: number;
-  pendingCount: number;
-  inProgressCount: number;
-  submittedCount: number;
-  completedCount: number;
-  skippedCount: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface SurveyTarget {
-  id: string;
-  campaignId: string;
-  asset: { id: string; code: string; name: string; typeName: string };
-  assignedUser: SurveyPerson | null;
-  status: SurveyTargetStatus;
-  dueAt: string | null;
-  instructions: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface SurveyCampaign extends SurveyCampaignListItem {
-  targets: SurveyTarget[];
-}
-
-export type SurveyReportOutcome = 'CONFIRMED' | 'CHANGES_RECORDED' | 'NOT_LOCATED';
-export type SurveyReportStatus = 'DRAFT' | 'SUBMITTED' | 'APPROVED' | 'REJECTED';
-export type SurveyReportVersionEvent = 'SUBMITTED' | 'APPROVED' | 'REJECTED';
-
-export interface SurveyTargetReport {
-  id: string;
-  targetId: string;
-  outcome: SurveyReportOutcome | null;
-  status: SurveyReportStatus;
-  observedAt: string | null;
-  latitude: number | null;
-  longitude: number | null;
-  accuracyM: number | null;
-  notes: string | null;
-  assetVersionAtSubmission: number | null;
-  submittedAt: string | null;
-  submittedBy: SurveyPerson | null;
-  reviewedAt: string | null;
-  reviewedBy: SurveyPerson | null;
-  reviewNotes: string | null;
-  selectedMediaIds: string[];
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface SurveyReportMedia extends AssetMedia {
-  kind: 'PHOTO';
-  selected: boolean;
-}
-
-export interface SurveyReportVersion {
-  id: string;
-  versionNumber: number;
-  event: SurveyReportVersionEvent;
-  snapshot: Record<string, unknown>;
-  actorUserId: string | null;
-  actorUsername: string | null;
-  createdAt: string;
-}
-
-export interface SurveyExecution {
-  target: {
-    id: string;
-    status: SurveyTargetStatus;
-    dueAt: string | null;
-    instructions: string | null;
-    assignedUser: SurveyPerson | null;
-  };
-  campaign: {
-    id: string;
-    code: string;
-    name: string;
-    status: SurveyCampaignStatus;
-  };
-  asset: {
-    id: string;
-    code: string;
-    name: string;
-    typeName: string;
-    informationStatus: AssetInformationStatus;
-    currentVersion: number;
-  };
-  report: SurveyTargetReport | null;
-  availableMedia: SurveyReportMedia[];
-  versions: SurveyReportVersion[];
-}
-
-export type InspectionVisitStatus =
-  | 'DRAFT' | 'PLANNED' | 'IN_PROGRESS' | 'CLOSED' | 'CANCELLED';
-
-export interface InspectionPerson {
-  id: string;
-  username: string;
-  firstName: string;
-  lastName: string;
-}
-
-export interface InspectionAssetSummary {
-  id: string;
-  code: string;
-  name: string;
-  commonName?: string | null;
-  typeName: string;
-  operatorCompany?: { id: string; code: string; name: string } | null;
-  operationalArea?: { id: string; code: string; name: string } | null;
-}
-
-export interface InspectionPlanningContextAsset {
-  id: string;
-  code: string;
-  name: string;
-}
-
-export type InspectionVisitAssetPlanningSource = 'LEGACY' | 'AUTOMATIC' | 'PREVENTIVE' | 'VERIFICATION';
-export type InspectionChecklistItemKind = 'ANTECEDENT' | 'COMPANY_OVERDUE' | 'VERIFICATION_OVERDUE' | 'UPCOMING_CONTROL';
-
-export interface InspectionPlannedAsset extends InspectionAssetSummary {
-  included: boolean;
-  planningSource: InspectionVisitAssetPlanningSource;
-  exclusionReason: string | null;
-  excludedAt: string | null;
-  excludedBy: InspectionPerson | null;
-}
-
-export interface InspectionVisitChecklistItem {
-  id: string;
-  findingId: string;
-  findingCode: string;
-  findingTitle: string;
-  findingStatus: InspectionFindingStatus;
-  severity: number | null;
-  itemKind: InspectionChecklistItemKind;
-  referenceOn: string | null;
-  asset: InspectionAssetSummary;
-  assetIncluded: boolean;
-}
-
-export interface InspectionVisitChecklistSummary {
-  generation: number;
-  generatedAt: string | null;
-  stale: boolean;
-  antecedents: number;
-  companyOverdue: number;
-  verificationOverdue: number;
-  upcomingControls: number;
-  actionableAssets: number;
-  excludedAssets: number;
-  items: InspectionVisitChecklistItem[];
-}
-
-export interface InspectionVisitListItem {
-  id: string;
-  code: string;
-  title: string;
-  objective: string | null;
-  status: InspectionVisitStatus;
-  scopeAsset: InspectionAssetSummary | null;
-  operationalArea: InspectionPlanningContextAsset | null;
-  operatorCompany: InspectionPlanningContextAsset | null;
-  leadInspector: InspectionPerson | null;
-  plannedStartAt: string | null;
-  plannedEndAt: string | null;
-  actualStartedAt: string | null;
-  actualClosedAt: string | null;
-  instructions: string | null;
-  cancellationReason: string | null;
-  checklistGeneration: number;
-  checklistGeneratedAt: string | null;
-  assetCount: number;
-  memberCount: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export type InspectionVerificationOutcome = 'RESOLVED' | 'NOT_RESOLVED' | 'REQUIRES_NEW_DATE';
-
-export interface InspectionVerificationFindingSummary {
-  id: string;
-  code: string;
-  title: string;
-  status: InspectionFindingStatus;
-  nextControlOn: string | null;
-  assetId: string;
-  assetCode: string;
-  assetName: string;
-  targetControlOn: string | null;
-  outcome: InspectionVerificationOutcome | null;
-  resultNotes: string | null;
-  verifiedAt: string | null;
-  resultRecordedAt: string | null;
-  rescheduledControlOn: string | null;
-  verificationEvidenceCount: number;
-}
-
-export interface InspectionVisit extends InspectionVisitListItem {
-  assets: InspectionAssetSummary[];
-  planningAssets: InspectionPlannedAsset[];
-  team: InspectionPerson[];
-  verificationFindings: InspectionVerificationFindingSummary[];
-  checklist: InspectionVisitChecklistSummary;
-}
-
-export type InspectionActStatus =
-  | 'DRAFT' | 'READY' | 'CLOSED' | 'CANCELLED' | 'RECTIFIED';
-
-export type InspectionActVersionEvent =
-  | 'CREATED' | 'UPDATED' | 'READY' | 'REOPENED' | 'CLOSED' | 'CANCELLED';
-
-export interface InspectionActListItem {
-  id: string;
-  visitId: string;
-  visit: {
-    id: string;
-    code: string;
-    title: string;
-    status: InspectionVisitStatus;
-    actualStartedAt: string | null;
-  };
-  actYear: number;
-  actNumber: number;
-  code: string;
-  status: InspectionActStatus;
-  occurredAt: string;
-  title: string;
-  summary: string;
-  observations: string | null;
-  currentVersion: number;
-  cancellationReason: string | null;
-  closedAt: string | null;
-  closedBy: string | null;
-  closureSha256: string | null;
-  assetCount: number;
-  findingCount: number;
-  companies: Array<{ id: string; code: string; name: string }>;
-  areas: Array<{ id: string; code: string; name: string }>;
-  report: null | {
-    id: string;
-    code: string;
-    status: InspectionReportStatus;
-    pdfStatus: InspectionReportPdfStatus;
-    generatedAt: string;
-  };
-  createdBy: InspectionPerson | null;
-  updatedBy: InspectionPerson | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface InspectionActVersion {
-  id: string;
-  versionNumber: number;
-  event: InspectionActVersionEvent;
-  snapshot: Record<string, unknown>;
-  actorUserId: string | null;
-  actorUsername: string | null;
-  createdAt: string;
-}
-
-export interface InspectionAct extends InspectionActListItem {
-  assets: InspectionAssetSummary[];
-  versions: InspectionActVersion[];
-}
-
-export type InspectionReportStatus = 'FROZEN' | 'CANCELLED';
-export type InspectionReportPdfStatus = 'PENDING' | 'READY' | 'FAILED';
-export type InspectionReportWordStatus = 'PENDING' | 'READY' | 'FAILED';
-export type InspectionReportReviewStatus = 'PENDING_REVIEW' | 'APPROVED' | 'SIGNED';
-
-export interface InspectionReportListItem {
-  id: string;
-  visitId: string;
-  actId: string;
-  reportYear: number;
-  reportNumber: number;
-  code: string;
-  status: InspectionReportStatus;
-  pdfStatus: InspectionReportPdfStatus;
-  wordStatus: InspectionReportWordStatus;
-  wordGeneratedAt: string | null;
-  reviewStatus: InspectionReportReviewStatus;
-  currentRevisionNumber: number;
-  approvedAt: string | null;
-  signedAt: string | null;
-  title: string;
-  actVersion: number;
-  actClosureSha256: string;
-  frozenSha256: string;
-  generatedAt: string;
-  generatedBy: InspectionPerson;
-  act: {
-    id: string;
-    code: string;
-    title: string;
-    status: InspectionActStatus;
-    occurredAt: string;
-    closedAt: string | null;
-  };
-  visit: {
-    id: string;
-    code: string;
-    title: string;
-    status: InspectionVisitStatus;
-  };
-  companies: Array<{ id: string; code: string; name: string }>;
-  areas: Array<{ id: string; code: string; name: string }>;
-  findingCount: number;
-}
-
-export interface InspectionReport extends InspectionReportListItem {
-  frozenSnapshot: Record<string, unknown>;
-}
-
-export type InspectionReportRevisionSource = 'AUTO' | 'DIRECTOR_UPLOAD';
-
-export interface InspectionReportRevision {
-  id: string;
-  reportId: string;
-  revisionNumber: number;
-  source: InspectionReportRevisionSource;
-  originalName: string;
-  mimeType: string;
-  sizeBytes: number;
-  sha256: string;
-  changeSummary: string | null;
-  createdAt: string;
-  createdBy: InspectionPerson;
-}
-
-export interface InspectionReportSignature {
-  id: string;
-  revisionId: string;
-  signedAt: string;
-  confirmationText: string;
-  signatureSha256: string;
-  signedBy: InspectionPerson;
-}
-
-export interface InspectionReportReview {
-  reportId: string;
-  reportCode: string;
-  reviewStatus: InspectionReportReviewStatus;
-  currentRevisionNumber: number;
-  approvedRevisionId: string | null;
-  approvedAt: string | null;
-  reviewNote: string | null;
-  approvedBy: InspectionPerson | null;
-  signature: InspectionReportSignature | null;
-  revisions: InspectionReportRevision[];
-}
-
-export interface PendingInspectionReportItem {
-  actId: string;
-  visitId: string;
-  actCode: string;
-  actTitle: string;
-  actYear: number;
-  occurredAt: string;
-  closedAt: string;
-  closureSha256: string;
-  visitCode: string;
-  visitTitle: string;
-  companies: Array<{ id: string; code: string; name: string }>;
-  areas: Array<{ id: string; code: string; name: string }>;
-  findingCount: number;
-}
-
-export type InspectionResponsibleAttendanceStatus = 'PRESENT' | 'ABSENT';
-export type InspectionResponsibleDocumentType = 'DNI' | 'CUIL' | 'PASSPORT' | 'OTHER';
-export type InspectionActSignatureStatus = 'SIGNED' | 'REFUSED' | 'ABSENT';
-export type InspectionActSignerType = 'INSPECTOR' | 'COMPANY_RESPONSIBLE';
-export type InspectionActUploadMode = 'IMMEDIATE' | 'DEFERRED';
-
-export interface InspectionActResponsible {
-  actId: string;
-  attendanceStatus: InspectionResponsibleAttendanceStatus;
-  fullName: string | null;
-  documentType: InspectionResponsibleDocumentType | null;
-  documentNumber: string | null;
-  position: string | null;
-  email: string | null;
-  phone: string | null;
-  absenceReason: string | null;
-  updatedBy: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface InspectionActSignature {
-  id: string;
-  actId: string;
-  signerType: InspectionActSignerType;
-  signerUserId: string | null;
-  signerName: string;
-  documentType: InspectionResponsibleDocumentType | null;
-  documentNumber: string | null;
-  position: string | null;
-  status: InspectionActSignatureStatus;
-  reason: string | null;
-  companyManifestation: 'CONFORMITY' | 'DISSENT' | null;
-  companyStatement: string | null;
-  mimeType: string | null;
-  sizeBytes: number | null;
-  imageSha256: string | null;
-  consentText: string | null;
-  consentVersion: string | null;
-  consentAcceptedAt: string | null;
-  clientSignedAt: string | null;
-  signedAt: string | null;
-  latitude: number | null;
-  longitude: number | null;
-  accuracyM: number | null;
-  deviceLabel: string | null;
-  source: 'WEB' | 'ANDROID';
-  preparedSha256: string;
-  signaturePayloadSha256: string;
-  uploadedBy: string;
-  uploadedByUsername: string;
-  createdAt: string;
-}
-
-export interface InspectionClosure {
-  act: {
-    id: string;
-    code: string;
-    status: InspectionActStatus;
-    visitId: string;
-    currentVersion: number;
-    closedAt: string | null;
-    closedBy: string | null;
-    closureSha256: string | null;
-  };
-  visit: {
-    id: string;
-    code: string;
-    status: InspectionVisitStatus;
-    actualClosedAt: string | null;
-  };
-  responsible: InspectionActResponsible | null;
-  closure: null | {
-    schemaVersion: string;
-    preparedSha256: string;
-    preparedAt: string;
-    preparedBy: string;
-    finalSha256: string | null;
-    deviceClosedAt: string | null;
-    serverClosedAt: string | null;
-    uploadMode: InspectionActUploadMode | null;
-    closedBy: string | null;
-    isCurrent: boolean;
-  };
-  signatures: InspectionActSignature[];
-  consents: {
-    version: string;
-    inspector: string;
-    company: string;
-  };
-}
-
-export interface FindingCategory {
-  id: string;
-  code: string;
-  name: string;
-  sortOrder: number;
-}
-
-export interface FindingCatalogItem {
-  id: string;
-  categoryId: string;
-  categoryName: string;
-  code: string;
-  sourceNumber: number;
-  title: string;
-  legalBasis: string | null;
-  glossary: string | null;
-  suggestedSeverity: number | null;
-  revision: number;
-}
-
-export interface FindingCatalog {
-  categories: FindingCategory[];
-  items: FindingCatalogItem[];
-}
-
-export interface FindingAdminCategory extends FindingCategory {
-  isActive: boolean;
-  itemCount: number;
-  activeItemCount: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface FindingAdminCatalogItem extends FindingCatalogItem {
-  categoryCode: string;
-  categoryActive: boolean;
-  importNote: string | null;
-  isActive: boolean;
-  usageCount: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface FindingAdminCatalog {
-  categories: FindingAdminCategory[];
-  items: FindingAdminCatalogItem[];
-}
-
-export interface FindingCatalogSelectionItem {
-  id: string;
-  categoryId: string;
-  categoryName: string;
-  code: string;
-  sourceNumber: number;
-  title: string;
-  suggestedSeverity: number | null;
-  enabled: boolean;
-}
-
-export interface FindingCatalogAssetTypeSelection {
-  assetType: { id: string; code: string; name: string; operationalRole: AssetTypeOperationalRole };
-  configured: boolean;
-  reason: string | null;
-  items: FindingCatalogSelectionItem[];
-}
-
-export interface FindingCatalogAssetSelection {
-  asset: {
-    id: string;
-    code: string;
-    name: string;
-    assetTypeId: string;
-    assetTypeCode: string;
-    assetTypeName: string;
-  };
-  typeConfigured: boolean;
-  typeReason: string | null;
-  items: Array<FindingCatalogSelectionItem & {
-    typeDefaultEnabled: boolean;
-    assetOverride: boolean | null;
-  }>;
-}
-
-export interface FindingCatalogApplicable extends FindingCatalog {
-  asset: FindingCatalogAssetSelection['asset'];
-  typeConfigured: boolean;
-  configurationReason: string | null;
-  other: { enabled: true; code: 'OTHER'; label: string; help: string };
-}
-
-export type FindingCatalogProposalStatus = 'PENDING' | 'MATCHED' | 'REJECTED';
-export interface FindingCatalogProposal {
-  id: string;
-  findingId: string;
-  findingCode: string;
-  assetId: string;
-  assetCode: string;
-  assetName: string;
-  assetTypeId: string;
-  assetTypeCode: string;
-  assetTypeName: string;
-  proposedTitle: string;
-  proposedLegalBasis: string | null;
-  proposedSeverity: number | null;
-  description: string;
-  status: FindingCatalogProposalStatus;
-  resolvedCatalogItemId: string | null;
-  resolvedCatalogCode: string | null;
-  resolvedCatalogTitle: string | null;
-  officeNotes: string | null;
-  reviewedBy: string | null;
-  reviewedByUsername: string | null;
-  reviewedAt: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export type InspectionFindingWorkflow =
-  | 'ALL'
-  | 'OPEN'
-  | 'WAITING_COMPANY'
-  | 'COMPANY_OVERDUE'
-  | 'TO_SCHEDULE_VERIFICATION'
-  | 'TO_VERIFY'
-  | 'VERIFICATION_OVERDUE'
-  | 'READY_TO_CLOSE'
-  | 'CLOSED';
-
-export interface InspectionFindingWorkflowCounters {
-  open: number;
-  waitingCompany: number;
-  companyOverdue: number;
-  companyDueNext7Days: number;
-  awaitingVerificationSchedule: number;
-  toVerify: number;
-  verificationOverdue: number;
-  verificationNext30Days: number;
-  readyToClose: number;
-  closed: number;
-}
-
-export interface InspectionFindingGlobalPage extends Page<InspectionFinding> {
-  counters: InspectionFindingWorkflowCounters;
-}
-
-export type VerificationPlanningStatus = 'ALL' | 'UNPLANNED' | 'PLANNED';
-
-export interface VerificationPlanningItem {
-  id: string;
-  code: string;
-  title: string;
-  status: 'OPEN';
-  nextControlOn: string;
-  companyResponseReceivedOn: string;
-  asset: { id: string; code: string; name: string; typeName: string };
-  company: { id: string; code: string; name: string } | null;
-  area: { id: string; code: string; name: string } | null;
-  act: { id: string; code: string };
-  sourceVisit: { id: string; code: string; title: string };
-  verificationVisit: null | {
-    id: string;
-    code: string;
-    title: string;
-    status: InspectionVisitStatus;
-    plannedStartAt: string | null;
-    plannedEndAt: string | null;
-  };
-}
-
-export interface VerificationPlanningCounters {
-  eligible: number;
-  unplanned: number;
-  overdueUnplanned: number;
-  dueNext30Days: number;
-  planned: number;
-}
-
-export interface VerificationPlanningPage extends Page<VerificationPlanningItem> {
-  counters: VerificationPlanningCounters;
-}
-
-export interface PlannedVerificationVisitResult {
-  visit: {
-    id: string;
-    code: string;
-    title: string;
-    status: InspectionVisitStatus;
-    plannedStartAt: string | null;
-    plannedEndAt: string | null;
-  };
-  company: { id: string; code: string; name: string };
-  area: { id: string; code: string; name: string };
-  findingCount: number;
-  assetCount: number;
-}
-
-export type InspectionFindingStatus = 'OPEN' | 'CLOSED' | 'VOIDED';
-export type InspectionFindingVerificationEventType =
-  | 'CONTROL_DATE_DEFINED'
-  | 'CONTROL_DATE_CHANGED'
-  | 'CONTROL_DATE_CLEARED'
-  | 'VISIT_PLANNED'
-  | 'RESULT_RECORDED';
-
-export interface InspectionFindingVerificationEvent {
-  id: string;
-  eventType: InspectionFindingVerificationEventType;
-  occurredAt: string;
-  targetControlOn: string | null;
-  previousControlOn: string | null;
-  nextControlOn: string | null;
-  outcome: InspectionVerificationOutcome | null;
-  notes: string | null;
-  actorUserId: string | null;
-  actorUsername: string | null;
-  verificationVisit: null | {
-    id: string;
-    code: string;
-    title: string;
-    status: InspectionVisitStatus;
-    plannedStartAt: string | null;
-  };
-  evidenceCount: number;
-}
-export type InspectionFindingVersionEvent = 'CREATED' | 'UPDATED' | 'FOLLOW_UP_UPDATED' | 'VERIFICATION_RECORDED';
-export type InspectionFindingOfficeStage =
-  | 'WAITING_COMPANY'
-  | 'COMPANY_OVERDUE'
-  | 'DEFINE_VERIFICATION'
-  | 'PLAN_VERIFICATION'
-  | 'VERIFICATION_PLANNED'
-  | 'RESCHEDULE_VERIFICATION'
-  | 'READY_TO_CLOSE'
-  | 'CLOSED';
-
-export interface InspectionFindingOfficeWorkflow {
-  stage: InspectionFindingOfficeStage;
-  label: string;
-  action: string;
-  dueOn: string | null;
-  overdue: boolean;
-}
-
-export interface InspectionFinding {
-  id: string;
-  actId: string;
-  assetId: string;
-  catalogItemId: string | null;
-  findingNumber: number;
-  code: string;
-  status: InspectionFindingStatus;
-  title: string;
-  description: string;
-  legalBasis: string | null;
-  glossary: string | null;
-  catalogRevision: number | null;
-  suggestedSeverity: number | null;
-  severity: number | null;
-  correctionDueOn: string | null;
-  responseDueBasis: 'FINDING_DATE' | 'REPORT_NOTIFICATION' | null;
-  responseDueDays: number | null;
-  responseDueBaseOn: string | null;
-  reportNotifiedOn: string | null;
-  companyResponse: string | null;
-  companyResponseReceivedOn: string | null;
-  companyCommittedCorrectionOn: string | null;
-  nextControlOn: string | null;
-  currentVersion: number;
-  closedAt: string | null;
-  closureNotes: string | null;
-  asset: InspectionAssetSummary;
-  catalog: {
-    id: string;
-    code: string;
-    categoryId: string;
-    categoryName: string;
-    sourceNumber: number;
-    revision: number;
-    suggestedSeverity: number | null;
-  } | null;
-  document: {
-    actId: string;
-    actCode: string;
-    actStatus: InspectionActStatus;
-    visitId: string;
-    visitCode: string;
-    visitTitle: string;
-    visitStatus: InspectionVisitStatus;
-  };
-  verificationVisit: null | {
-    id: string;
-    code: string;
-    title: string;
-    status: InspectionVisitStatus;
-    plannedStartAt: string | null;
-  };
-  latestVerification: null | {
-    visitId: string;
-    visitCode: string;
-    visitStatus: InspectionVisitStatus;
-    targetControlOn: string | null;
-    outcome: InspectionVerificationOutcome | null;
-    resultNotes: string | null;
-    verifiedAt: string | null;
-    resultRecordedAt: string | null;
-    rescheduledControlOn: string | null;
-    evidenceCount: number;
-  };
-  verificationHistory?: InspectionFindingVerificationEvent[];
-  createdAt: string;
-  updatedAt: string;
-  officeWorkflow?: InspectionFindingOfficeWorkflow;
-  versions?: Array<{
-    id: string;
-    versionNumber: number;
-    event: InspectionFindingVersionEvent;
-    snapshot: Record<string, unknown>;
-    actorUserId: string | null;
-    actorUsername: string | null;
-    createdAt: string;
-  }>;
-}
-
-export type InspectionEvidenceKind = 'PHOTO' | 'DOCUMENT';
-export type InspectionEvidencePurpose =
-  | 'OBSERVATION'
-  | 'VERIFICATION'
-  | 'COMPANY_RESPONSE'
-  | 'COMMUNICATION_ATTACHMENT'
-  | 'OTHER_DOCUMENT';
-
-export interface InspectionFindingCommunication {
-  id: string;
-  findingId: string;
-  direction: 'INBOUND' | 'OUTBOUND' | 'INTERNAL';
-  channel: 'EMAIL' | 'IN_PERSON' | 'PHONE' | 'LETTER' | 'SYSTEM' | 'OTHER';
-  type: 'COMPANY_RESPONSE' | 'AUTHORITY_NOTICE' | 'FOLLOW_UP' | 'OTHER';
-  occurredAt: string;
-  subject: string;
-  details: string | null;
-  contactName: string | null;
-  contactEmail: string | null;
-  createdBy: string | null;
-  createdByUsername: string | null;
-  attachmentCount: number;
-  createdAt: string;
-}
-
-export interface InspectionFindingEvidence {
-  id: string;
-  findingId: string;
-  communicationId: string | null;
-  verificationVisitId: string | null;
-  communication: {
-    id: string;
-    type: InspectionFindingCommunication['type'];
-    direction: InspectionFindingCommunication['direction'];
-    subject: string;
-  } | null;
-  kind: InspectionEvidenceKind;
-  purpose: InspectionEvidencePurpose;
-  originalName: string;
-  mimeType: string;
-  sizeBytes: number;
-  sha256: string;
-  title: string | null;
-  description: string | null;
-  capturedAt: string | null;
-  latitude: number | null;
-  longitude: number | null;
-  accuracyM: number | null;
-  deviceLabel: string | null;
-  source: 'WEB' | 'ANDROID' | 'IMPORT';
-  uploadedBy: string | null;
-  uploadedByUsername: string | null;
-  createdAt: string;
-}
-
-let csrfToken: string | null = null;
-let refreshPromise: Promise<void> | null = null;
-
-function readCsrfCookie(): string | null {
-  if (typeof document === 'undefined') return null;
-  const cookies = document.cookie.split(';').map((item) => item.trim());
-  const exact = cookies.find((item) => item.startsWith('dhv2_csrf='));
-  const fallback = cookies.find((item) => item.split('=', 1)[0]?.endsWith('_csrf'));
-  const raw = exact ?? fallback;
-  if (!raw) return null;
-  const separator = raw.indexOf('=');
-  return separator >= 0 ? decodeURIComponent(raw.slice(separator + 1)) : null;
-}
-
-function isUnsafe(method: string): boolean {
-  return !['GET', 'HEAD', 'OPTIONS'].includes(method.toUpperCase());
-}
-
-async function decodeResponse<T>(response: Response): Promise<T> {
-  const body = await response.json().catch(() => null) as {
-    code?: string;
-    message?: string;
-    requestId?: string;
-  } | null;
-  if (!response.ok) {
-    throw new ApiError(
-      response.status,
-      body?.code ?? 'REQUEST_ERROR',
-      body?.message ?? `La solicitud falló con HTTP ${response.status}`,
-      body?.requestId,
-    );
-  }
-  return body as T;
-}
-
-async function rawRequest<T>(path: string, init: RequestInit = {}): Promise<T> {
-  const method = (init.method ?? 'GET').toUpperCase();
-  const headers = new Headers(init.headers);
-  headers.set('Accept', 'application/json');
-  if (init.body && !(init.body instanceof FormData)) {
-    headers.set('Content-Type', 'application/json');
-  }
-  if (isUnsafe(method) && path !== '/auth/login') {
-    const token = csrfToken ?? readCsrfCookie();
-    if (token) headers.set('x-csrf-token', token);
-  }
-
-  const response = await fetch(`${API_BASE}${path}`, {
-    ...init,
-    method,
-    headers,
-    credentials: 'include',
-    cache: 'no-store',
-  });
-  return decodeResponse<T>(response);
-}
-
-async function refreshAccess(): Promise<void> {
-  if (!refreshPromise) {
-    refreshPromise = rawRequest<AuthResponse>('/auth/refresh', { method: 'POST' })
-      .then((response) => { csrfToken = response.csrfToken; })
-      .finally(() => { refreshPromise = null; });
-  }
-  return refreshPromise;
-}
-
-export async function apiRequest<T>(
-  path: string,
-  init: RequestInit = {},
-  retrySession = true,
-): Promise<T> {
-  try {
-    return await rawRequest<T>(path, init);
-  } catch (error) {
-    if (
-      retrySession && error instanceof ApiError && error.status === 401 &&
-      path !== '/auth/login' && path !== '/auth/refresh'
-    ) {
-      try {
-        await refreshAccess();
-        return await rawRequest<T>(path, init);
-      } catch (refreshError) {
-        csrfToken = null;
-        window.dispatchEvent(new Event('dhv2:unauthorized'));
-        throw refreshError;
-      }
-    }
-    throw error;
-  }
-}
-
-async function rawBlobRequest(path: string): Promise<Blob> {
-  const response = await fetch(`${API_BASE}${path}`, {
-    method: 'GET',
-    headers: { Accept: '*/*' },
-    credentials: 'include',
-    cache: 'no-store',
-  });
-  if (!response.ok) return decodeResponse<never>(response);
-  return response.blob();
-}
-
-async function apiBlobRequest(path: string): Promise<Blob> {
-  try {
-    return await rawBlobRequest(path);
-  } catch (error) {
-    if (error instanceof ApiError && error.status === 401) {
-      try {
-        await refreshAccess();
-        return await rawBlobRequest(path);
-      } catch (refreshError) {
-        csrfToken = null;
-        window.dispatchEvent(new Event('dhv2:unauthorized'));
-        throw refreshError;
-      }
-    }
-    throw error;
-  }
-}
-
-export function getHealth() { return apiRequest<HealthResponse>('/health', {}, false); }
-
-export async function login(identifier: string, password: string) {
-  const response = await apiRequest<AuthResponse>('/auth/login', {
-    method: 'POST',
-    body: JSON.stringify({ identifier, password, deviceLabel: 'Panel web' }),
-  }, false);
-  csrfToken = response.csrfToken;
-  return response;
-}
-
-export async function getMe() {
-  const response = await apiRequest<{ user: AuthUser }>('/auth/me');
-  return response.user;
-}
-
-export async function logout() {
-  await apiRequest<{ status: string }>('/auth/logout', { method: 'POST' });
-  csrfToken = null;
-}
-
-export function changePassword(currentPassword: string, newPassword: string) {
-  return apiRequest<{ status: string; mustChangePassword: false }>('/auth/change-password', {
-    method: 'POST', body: JSON.stringify({ currentPassword, newPassword }),
-  });
-}
-
-export function getDashboardSummary() { return apiRequest<DashboardSummary>('/dashboard/summary'); }
-
-export function listUsers(params: {
-  page?: number; pageSize?: number; search?: string; status?: 'ACTIVE' | 'INACTIVE' | '';
-} = {}) {
-  const query = new URLSearchParams();
-  query.set('page', String(params.page ?? 1));
-  query.set('pageSize', String(params.pageSize ?? 20));
-  if (params.search) query.set('search', params.search);
-  if (params.status) query.set('status', params.status);
-  return apiRequest<Page<AdministrativeUser>>(`/users?${query}`);
-}
-
-export function getUser(id: string) { return apiRequest<AdministrativeUser>(`/users/${id}`); }
-
-export function createUser(input: {
-  username: string; email?: string; firstName: string; lastName: string;
-  password: string; mustChangePassword: boolean; roleIds: string[];
-}) {
-  return apiRequest<AdministrativeUser>('/users', {
-    method: 'POST', body: JSON.stringify(input),
-  });
-}
-
-export function updateUser(id: string, input: {
-  username?: string; email?: string | null; firstName?: string; lastName?: string;
-}) {
-  return apiRequest<AdministrativeUser>(`/users/${id}`, {
-    method: 'PATCH', body: JSON.stringify(input),
-  });
-}
-
-export function resetUserPassword(id: string, password: string, mustChangePassword = true) {
-  return apiRequest<AdministrativeUser>(`/users/${id}/reset-password`, {
-    method: 'POST',
-    body: JSON.stringify({ password, mustChangePassword }),
-  });
-}
-
-export function updateUserStatus(id: string, status: 'ACTIVE' | 'INACTIVE') {
-  return apiRequest<AdministrativeUser>(`/users/${id}/status`, {
-    method: 'PATCH', body: JSON.stringify({ status }),
-  });
-}
-
-export function replaceUserRoles(id: string, roleIds: string[]) {
-  return apiRequest<AdministrativeUser>(`/users/${id}/roles`, {
-    method: 'PUT', body: JSON.stringify({ roleIds }),
-  });
-}
-
-export async function listRoles() {
-  return (await apiRequest<{ data: AdministrativeRole[] }>('/roles')).data;
-}
-
-export async function listPermissions() {
-  return (await apiRequest<{ data: Permission[] }>('/roles/permissions')).data;
-}
-
-export function createRole(input: {
-  code: string; name: string; description: string; permissionIds: string[];
-}) {
-  return apiRequest<AdministrativeRole>('/roles', {
-    method: 'POST', body: JSON.stringify(input),
-  });
-}
-
-export function updateRole(id: string, input: { name: string; description: string }) {
-  return apiRequest<AdministrativeRole>(`/roles/${id}`, {
-    method: 'PATCH', body: JSON.stringify(input),
-  });
-}
-
-export function replaceRolePermissions(id: string, permissionIds: string[]) {
-  return apiRequest<AdministrativeRole>(`/roles/${id}/permissions`, {
-    method: 'PUT', body: JSON.stringify({ permissionIds }),
-  });
-}
-
-export function listAudit(params: Record<string, string | number | undefined>) {
-  const query = new URLSearchParams();
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== undefined && value !== '') query.set(key, String(value));
-  });
-  return apiRequest<Page<AuditEventSummary>>(`/audit?${query}`);
-}
-
-export function getAuditEvent(id: string) {
-  return apiRequest<AuditEventDetail>(`/audit/${id}`);
-}
-
-export async function listAssetTypes() {
-  return (await apiRequest<{ data: AssetType[] }>('/asset-types')).data;
-}
-
-export function getMasterBootstrapStatus() {
-  return apiRequest<MasterBootstrapStatus>('/asset-types/bootstrap-status');
-}
-
-export function bootstrapMasterDefaults() {
-  return apiRequest<MasterBootstrapResult>('/asset-types/bootstrap-defaults', {
-    method: 'POST',
-  });
-}
-
-export function getMasterEnrichmentStatus() {
-  return apiRequest<MasterEnrichmentStatus>('/asset-types/enrichment-status');
-}
-
-export function enrichMasterDefaults() {
-  return apiRequest<MasterBootstrapResult>('/asset-types/enrich-defaults', {
-    method: 'POST',
-  });
-}
-
-export async function listOperationalAreas(parentId?: string) {
-  const query = parentId ? `?${new URLSearchParams({ parentId })}` : '';
-  return (await apiRequest<{ data: OperationalAssetSummary[] }>(`/asset-operational-relations/areas${query}`)).data;
-}
-
-export async function listOperationalCompanies() {
-  return (await apiRequest<{ data: OperationalAssetSummary[] }>('/asset-operational-relations/companies')).data;
-}
-
-export async function listCompaniesForArea(areaId: string) {
-  return (await apiRequest<{ data: OperationalAssetSummary[] }>(`/asset-operational-relations/areas/${areaId}/companies`)).data;
-}
-
-export async function listAreasForCompany(companyId: string) {
-  return (await apiRequest<{ data: OperationalAssetSummary[] }>(`/asset-operational-relations/companies/${companyId}/areas`)).data;
-}
-
-export async function listAreaCompanyRelations(params: {
-  areaId?: string;
-  companyId?: string;
-  includeHistory?: boolean;
-} = {}) {
-  const query = new URLSearchParams();
-  if (params.areaId) query.set('areaId', params.areaId);
-  if (params.companyId) query.set('companyId', params.companyId);
-  if (params.includeHistory) query.set('includeHistory', 'true');
-  const suffix = query.size ? `?${query}` : '';
-  return (await apiRequest<{ data: AreaCompanyRelation[] }>(`/asset-operational-relations${suffix}`)).data;
-}
-
-export function createAreaCompanyRelation(input: { areaId: string; companyId: string; relationRole?: AreaOrganizationRole; participationPercent?: number | null; legalInstrument?: string | null; sourceDocumentId?: string | null; reason: string }) {
-  return apiRequest<AreaCompanyRelation>('/asset-operational-relations', {
-    method: 'POST', body: JSON.stringify(input),
-  });
-}
-
-export function endAreaCompanyRelation(id: string, reason: string) {
-  return apiRequest<AreaCompanyRelation>(`/asset-operational-relations/${id}/end`, {
-    method: 'POST', body: JSON.stringify({ reason }),
-  });
-}
-
-export function createAssetType(input: {
-  code: string;
-  name: string;
-  description: string;
-  canBeRoot: boolean;
-  operationalRole: AssetTypeOperationalRole;
-  allowedParentTypeIds: string[];
-}) {
-  return apiRequest<AssetType>('/asset-types', {
-    method: 'POST', body: JSON.stringify(input),
-  });
-}
-
-export function updateAssetType(id: string, input: {
-  name?: string;
-  description?: string;
-  canBeRoot?: boolean;
-  isActive?: boolean;
-  operationalRole?: AssetTypeOperationalRole;
-  allowedParentTypeIds?: string[];
-}) {
-  return apiRequest<AssetType>(`/asset-types/${id}`, {
-    method: 'PATCH', body: JSON.stringify(input),
-  });
-}
-
-export function createAssetAttribute(typeId: string, input: {
-  code: string;
-  name: string;
-  dataType: AssetAttributeDataType;
-  isRequired: boolean;
-  unit?: string | null;
-  options?: string[];
-  sortOrder: number;
-}) {
-  return apiRequest<AssetType>(`/asset-types/${typeId}/attributes`, {
-    method: 'POST', body: JSON.stringify(input),
-  });
-}
-
-export function updateAssetAttribute(
-  typeId: string,
-  attributeId: string,
-  input: {
-    name?: string;
-    dataType?: AssetAttributeDataType;
-    isRequired?: boolean;
-    isActive?: boolean;
-    unit?: string | null;
-    options?: string[] | null;
-    sortOrder?: number;
-  },
-) {
-  return apiRequest<AssetType>(`/asset-types/${typeId}/attributes/${attributeId}`, {
-    method: 'PATCH', body: JSON.stringify(input),
-  });
-}
-
-export function listAssets(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  typeId?: string;
-  status?: AssetInformationStatus | '';
-  operationalStatus?: AssetOperationalStatus | '';
-  needsValidation?: boolean;
-  hasGeometry?: boolean;
-  parentId?: string;
-  operationalAreaId?: string;
-  operatorCompanyId?: string;
-} = {}) {
-  const query = new URLSearchParams();
-  query.set('page', String(params.page ?? 1));
-  query.set('pageSize', String(params.pageSize ?? 25));
-  if (params.search) query.set('search', params.search);
-  if (params.typeId) query.set('typeId', params.typeId);
-  if (params.status) query.set('status', params.status);
-  if (params.operationalStatus) query.set('operationalStatus', params.operationalStatus);
-  if (params.needsValidation !== undefined) query.set('needsValidation', String(params.needsValidation));
-  if (params.hasGeometry !== undefined) query.set('hasGeometry', String(params.hasGeometry));
-  if (params.parentId) query.set('parentId', params.parentId);
-  if (params.operationalAreaId) query.set('operationalAreaId', params.operationalAreaId);
-  if (params.operatorCompanyId) query.set('operatorCompanyId', params.operatorCompanyId);
-  return apiRequest<Page<AssetListItem>>(`/assets?${query}`);
-}
-
-export async function listAssetTree(params: {
-  search?: string;
-  typeId?: string;
-  status?: AssetInformationStatus | '';
-  operationalStatus?: AssetOperationalStatus | '';
-  operationalAreaId?: string;
-  operatorCompanyId?: string;
-  needsValidation?: boolean;
-  hasGeometry?: boolean;
-} = {}) {
-  const query = new URLSearchParams();
-  if (params.search) query.set('search', params.search);
-  if (params.typeId) query.set('typeId', params.typeId);
-  if (params.status) query.set('status', params.status);
-  if (params.operationalStatus) query.set('operationalStatus', params.operationalStatus);
-  if (params.operationalAreaId) query.set('operationalAreaId', params.operationalAreaId);
-  if (params.operatorCompanyId) query.set('operatorCompanyId', params.operatorCompanyId);
-  if (params.needsValidation !== undefined) query.set('needsValidation', String(params.needsValidation));
-  if (params.hasGeometry !== undefined) query.set('hasGeometry', String(params.hasGeometry));
-  const suffix = query.toString() ? `?${query}` : '';
-  return apiRequest<{ data: AssetListItem[]; meta: { count: number; truncated: boolean } }>(`/assets/tree${suffix}`);
-}
-
-export async function listAssetTreeChildren(params: {
-  parentId?: string; search?: string; typeId?: string; status?: AssetInformationStatus | '';
-  operationalStatus?: AssetOperationalStatus | ''; operationalAreaId?: string; operatorCompanyId?: string;
-  needsValidation?: boolean; hasGeometry?: boolean; limit?: number;
-} = {}) {
-  const query = new URLSearchParams();
-  if (params.parentId) query.set('parentId', params.parentId);
-  if (params.search) query.set('search', params.search);
-  if (params.typeId) query.set('typeId', params.typeId);
-  if (params.status) query.set('status', params.status);
-  if (params.operationalStatus) query.set('operationalStatus', params.operationalStatus);
-  if (params.operationalAreaId) query.set('operationalAreaId', params.operationalAreaId);
-  if (params.operatorCompanyId) query.set('operatorCompanyId', params.operatorCompanyId);
-  if (params.needsValidation !== undefined) query.set('needsValidation', String(params.needsValidation));
-  if (params.hasGeometry !== undefined) query.set('hasGeometry', String(params.hasGeometry));
-  query.set('limit', String(params.limit ?? 100));
-  return apiRequest<{ data: AssetListItem[]; meta: { count: number; hasMore: boolean; parentId: string | null } }>(`/assets/tree-children?${query}`);
-}
-
-export async function listAssetParentOptions(
-  childTypeId: string,
-  assetId?: string,
-  search?: string,
-) {
-  const query = new URLSearchParams({ childTypeId });
-  if (assetId) query.set('assetId', assetId);
-  if (search) query.set('search', search);
-  return (await apiRequest<{ data: AssetListItem[] }>(`/assets/parent-options?${query}`)).data;
-}
-
-export function getAsset(id: string) {
-  return apiRequest<AssetDetail>(`/assets/${id}`);
-}
-
-export function getAssetDossier(id: string) {
-  return apiRequest<AssetDossier>(`/assets/${id}/dossier`);
-}
-
-export async function getAssetLineage(id: string) {
-  return (await apiRequest<{ data: AssetLineageItem[] }>(`/assets/${id}/lineage`)).data;
-}
-
-export function createAsset(input: {
-  code: string;
-  name: string;
-  commonName?: string | null;
-  typeId: string;
-  parentId?: string | null;
-  operationalAreaId?: string | null;
-  operatorCompanyId?: string | null;
-  description?: string | null;
-  informationStatus?: AssetInformationStatus;
-  attributes: Record<string, unknown>;
-}) {
-  return apiRequest<AssetDetail>('/assets', {
-    method: 'POST', body: JSON.stringify(input),
-  });
-}
-
-export function updateAsset(id: string, input: {
-  typeId?: string;
-  code?: string;
-  name?: string;
-  commonName?: string | null;
-  parentId?: string | null;
-  operationalAreaId?: string | null;
-  operatorCompanyId?: string | null;
-  description?: string | null;
-  attributes?: Record<string, unknown>;
-}) {
-  return apiRequest<AssetDetail>(`/assets/${id}`, {
-    method: 'PATCH', body: JSON.stringify(input),
-  });
-}
-
-export function updateAssetInformationStatus(
-  id: string,
-  informationStatus: AssetInformationStatus,
-) {
-  return apiRequest<AssetDetail>(`/assets/${id}/information-status`, {
-    method: 'PATCH', body: JSON.stringify({ informationStatus }),
-  });
-}
-
-export function updateAssetOperationalStatus(id: string, status: AssetOperationalStatus) {
-  return apiRequest<AssetDetail>(`/assets/${id}/operational-status`, {
-    method: 'PATCH', body: JSON.stringify({ status }),
-  });
-}
-
-
-export async function listAssetContextHistory(assetId: string) {
-  return (await apiRequest<{ data: AssetContextHistoryItem[] }>(`/assets/${assetId}/context-history`)).data;
-}
-
-export function changeAssetContext(assetId: string, input: {
-  parentId?: string | null;
-  operationalAreaId?: string | null;
-  operatorCompanyId?: string | null;
-  effectiveAt?: string;
-  reason: string;
-}) {
-  return apiRequest<AssetDetail>(`/assets/${assetId}/context`, {
-    method: 'POST', body: JSON.stringify(input),
-  });
-}
-
-export function listFieldDiscoveries(params: { page?: number; pageSize?: number; status?: FieldDiscoveryStatus; search?: string } = {}) {
-  const query = new URLSearchParams();
-  query.set('page', String(params.page ?? 1));
-  query.set('pageSize', String(params.pageSize ?? 25));
-  if (params.status) query.set('status', params.status);
-  if (params.search) query.set('search', params.search);
-  return apiRequest<Page<FieldDiscovery>>(`/assets/field-discoveries?${query}`);
-}
-
-export function approveFieldDiscovery(id: string, notes?: string | null) {
-  return apiRequest<FieldDiscovery>(`/assets/field-discoveries/${id}/approve`, { method: 'POST', body: JSON.stringify({ notes: notes || null }) });
-}
-
-export function rejectFieldDiscovery(id: string, reason: string) {
-  return apiRequest<FieldDiscovery>(`/assets/field-discoveries/${id}/reject`, { method: 'POST', body: JSON.stringify({ reason }) });
-}
-
-export function matchFieldDiscovery(id: string, matchedAssetId: string, reason: string) {
-  return apiRequest<FieldDiscovery>(`/assets/field-discoveries/${id}/match`, { method: 'POST', body: JSON.stringify({ matchedAssetId, reason }) });
-}
-
-export function getAssetRegistry(assetId: string) {
-  return apiRequest<AssetRegistry>(`/assets/${assetId}/registry`);
-}
-export async function listSourceDocuments(search = '') {
-  const suffix = search.trim() ? `?search=${encodeURIComponent(search.trim())}` : '';
-  return (await apiRequest<{ data: SourceDocumentSummary[] }>(`/source-documents${suffix}`)).data;
-}
-export function createSourceDocument(input: { documentType: SourceDocumentType; documentNumber?: string | null; title: string; issuer?: string | null; documentDate?: string | null; externalReference?: string | null; notes?: string | null }) {
-  return apiRequest<SourceDocumentSummary>('/source-documents', { method: 'POST', body: JSON.stringify(input) });
-}
-export function linkAssetSourceDocument(assetId: string, documentId: string, input: { relationType: AssetSourceDocumentRelationType; notes?: string | null }) {
-  return apiRequest(`/assets/${assetId}/source-documents/${documentId}`, { method: 'POST', body: JSON.stringify(input) });
-}
-export function addAssetExternalIdentifier(assetId: string, input: { namespace: string; value: string; validFrom?: string | null; sourceDocumentId?: string | null; notes?: string | null }) {
-  return apiRequest(`/assets/${assetId}/external-identifiers`, { method: 'POST', body: JSON.stringify(input) });
-}
-export function endAssetExternalIdentifier(id: string, reason: string) {
-  return apiRequest(`/asset-external-identifiers/${id}/end`, { method: 'POST', body: JSON.stringify({ reason }) });
-}
-export function upsertOrganizationProfile(assetId: string, input: { organizationKind: OrganizationKind; legalName?: string | null; taxId?: string | null; notificationEmail?: string | null; notes?: string | null }) {
-  return apiRequest(`/assets/${assetId}/organization-profile`, { method: 'PATCH', body: JSON.stringify(input) });
-}
-export function addOrganizationMembership(organizationId: string, input: { memberOrganizationId: string; role: OrganizationMembershipRole; participationPercent?: number | null; validFrom?: string | null; sourceDocumentId?: string | null; notes?: string | null }) {
-  return apiRequest(`/organizations/${organizationId}/memberships`, { method: 'POST', body: JSON.stringify(input) });
-}
-export function endOrganizationMembership(id: string, reason: string) {
-  return apiRequest(`/organization-memberships/${id}/end`, { method: 'POST', body: JSON.stringify({ reason }) });
-}
-export function createAreaLegalRight(areaId: string, input: { rightType: AreaLegalRightType; name: string; instrumentNumber?: string | null; validFrom?: string | null; validUntil?: string | null; status?: AreaLegalRightStatus; sourceDocumentId?: string | null; notes?: string | null }) {
-  return apiRequest(`/areas/${areaId}/legal-rights`, { method: 'POST', body: JSON.stringify(input) });
-}
-export function addAreaLegalRightOrganization(rightId: string, input: { organizationId: string; role: AreaLegalRightOrganizationRole; participationPercent?: number | null; validFrom?: string | null; notes?: string | null }) {
-  return apiRequest(`/area-legal-rights/${rightId}/organizations`, { method: 'POST', body: JSON.stringify(input) });
-}
-export function endAreaLegalRightOrganization(id: string, reason: string) {
-  return apiRequest(`/area-legal-right-organizations/${id}/end`, { method: 'POST', body: JSON.stringify({ reason }) });
-}
-
-export async function getAssetGeometry(assetId: string) {
-  return (await apiRequest<{ data: AssetGeometry | null }>(`/assets/${assetId}/geometry`)).data;
-}
-
-export function upsertAssetGeometry(assetId: string, input: {
-  geometry: GeoJsonGeometry;
-  accuracyM?: number | null;
-  capturedAt?: string | null;
-  deviceLabel?: string | null;
-}) {
-  return apiRequest<AssetGeometry>(`/assets/${assetId}/geometry`, {
-    method: 'PUT', body: JSON.stringify(input),
-  });
-}
-
-export function removeAssetGeometry(assetId: string) {
-  return apiRequest<{ status: 'removed' | 'absent' }>(`/assets/${assetId}/geometry`, {
-    method: 'DELETE',
-  });
-}
-
-export function getMapAssets(params: {
-  bbox?: string;
-  typeId?: string;
-  status?: AssetInformationStatus | '';
-  geometryType?: AssetGeometryType | '';
-} = {}) {
-  const query = new URLSearchParams();
-  if (params.bbox) query.set('bbox', params.bbox);
-  if (params.typeId) query.set('typeId', params.typeId);
-  if (params.status) query.set('status', params.status);
-  if (params.geometryType) query.set('geometryType', params.geometryType);
-  const suffix = query.size ? `?${query}` : '';
-  return apiRequest<MapAssetFeatureCollection>(`/map/assets${suffix}`);
-}
-
-export function listAssetVersions(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  typeId?: string;
-  status?: AssetInformationStatus | '';
-  changeType?: AssetVersionChangeType | '';
-  from?: string;
-  to?: string;
-} = {}) {
-  const query = new URLSearchParams();
-  query.set('page', String(params.page ?? 1));
-  query.set('pageSize', String(params.pageSize ?? 25));
-  if (params.search) query.set('search', params.search);
-  if (params.typeId) query.set('typeId', params.typeId);
-  if (params.status) query.set('status', params.status);
-  if (params.changeType) query.set('changeType', params.changeType);
-  if (params.from) query.set('from', params.from);
-  if (params.to) query.set('to', params.to);
-  return apiRequest<Page<AssetVersionSummary>>(`/asset-versions?${query}`);
-}
-
-export function listAssetVersionTimeline(
-  assetId: string,
-  params: { page?: number; pageSize?: number } = {},
-) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 10),
-  });
-  return apiRequest<Page<AssetVersionSummary>>(`/assets/${assetId}/versions?${query}`);
-}
-
-export function getAssetVersion(assetId: string, versionNumber: number) {
-  return apiRequest<AssetVersionDetail>(`/assets/${assetId}/versions/${versionNumber}`);
-}
-
-export async function listAssetMedia(assetId: string) {
-  return (await apiRequest<{ data: AssetMedia[] }>(`/assets/${assetId}/media`)).data;
-}
-
-export function uploadAssetMedia(assetId: string, input: {
-  file: File;
-  kind: AssetMediaKind;
-  title?: string;
-  description?: string;
-  capturedAt?: string;
-  latitude?: number;
-  longitude?: number;
-  accuracyM?: number;
-}) {
-  const body = new FormData();
-  body.append('file', input.file);
-  body.append('kind', input.kind);
-  if (input.title) body.append('title', input.title);
-  if (input.description) body.append('description', input.description);
-  if (input.capturedAt) body.append('capturedAt', input.capturedAt);
-  if (input.latitude !== undefined) body.append('latitude', String(input.latitude));
-  if (input.longitude !== undefined) body.append('longitude', String(input.longitude));
-  if (input.accuracyM !== undefined) body.append('accuracyM', String(input.accuracyM));
-  return apiRequest<AssetMedia>(`/assets/${assetId}/media`, {
-    method: 'POST',
-    body,
-  });
-}
-
-export function updateAssetMedia(mediaId: string, input: {
-  title?: string | null;
-  description?: string | null;
-  capturedAt?: string | null;
-  latitude?: number | null;
-  longitude?: number | null;
-  accuracyM?: number | null;
-}) {
-  return apiRequest<AssetMedia>(`/asset-media/${mediaId}`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export function removeAssetMedia(mediaId: string) {
-  return apiRequest<{ status: 'removed' }>(`/asset-media/${mediaId}`, {
-    method: 'DELETE',
-  });
-}
-
-export function getAssetMediaBlob(mediaId: string, download = false) {
-  return apiBlobRequest(`/asset-media/${mediaId}/content${download ? '?download=1' : ''}`);
-}
-
-export function getAssetProvenance(assetId: string) {
-  return apiRequest<AssetProvenance>(`/assets/${assetId}/provenance`);
-}
-
-export function updateAssetProvenance(assetId: string, input: {
-  origin: AssetDataOrigin;
-  sourceName?: string | null;
-  sourceReference?: string | null;
-  observedAt?: string | null;
-  notes?: string | null;
-}) {
-  return apiRequest<AssetProvenance>(`/assets/${assetId}/provenance`, {
-    method: 'PUT',
-    body: JSON.stringify(input),
-  });
-}
-
-export function verifyAssetProvenance(assetId: string) {
-  return apiRequest<AssetProvenance>(`/assets/${assetId}/provenance/verify`, {
-    method: 'POST',
-  });
-}
-
-export function listTemporalAssets(params: {
-  at: string;
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  typeId?: string;
-  status?: AssetInformationStatus | '';
-}) {
-  const query = new URLSearchParams({
-    at: params.at,
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.typeId) query.set('typeId', params.typeId);
-  if (params.status) query.set('status', params.status);
-  return apiRequest<Page<TemporalAssetSummary> & { asOf: string }>(
-    `/temporal-assets?${query}`,
-  );
-}
-
-export function getTemporalAsset(assetId: string, at: string) {
-  const query = new URLSearchParams({ at });
-  return apiRequest<TemporalAssetDetail>(`/temporal-assets/${assetId}?${query}`);
-}
-
-export function listSurveyCampaigns(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  status?: SurveyCampaignStatus | '';
-  coordinatorUserId?: string;
-} = {}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.status) query.set('status', params.status);
-  if (params.coordinatorUserId) query.set('coordinatorUserId', params.coordinatorUserId);
-  return apiRequest<Page<SurveyCampaignListItem>>(`/survey-campaigns?${query}`);
-}
-
-export function getSurveyCampaign(id: string) {
-  return apiRequest<SurveyCampaign>(`/survey-campaigns/${id}`);
-}
-
-export async function listSurveyAssignees() {
-  return (await apiRequest<{ data: SurveyPerson[] }>('/survey-campaigns/assignees')).data;
-}
-
-export function createSurveyCampaign(input: {
-  code: string;
-  name: string;
-  description?: string | null;
-  plannedStartAt?: string | null;
-  plannedEndAt?: string | null;
-  scopeAssetId?: string | null;
-  coordinatorUserId?: string | null;
-}) {
-  return apiRequest<SurveyCampaign>('/survey-campaigns', {
-    method: 'POST',
-    body: JSON.stringify(input),
-  });
-}
-
-export function updateSurveyCampaign(id: string, input: {
-  code?: string;
-  name?: string;
-  description?: string | null;
-  plannedStartAt?: string | null;
-  plannedEndAt?: string | null;
-  scopeAssetId?: string | null;
-  coordinatorUserId?: string | null;
-}) {
-  return apiRequest<SurveyCampaign>(`/survey-campaigns/${id}`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export function updateSurveyCampaignStatus(id: string, status: SurveyCampaignStatus) {
-  return apiRequest<SurveyCampaign>(`/survey-campaigns/${id}/status`, {
-    method: 'PUT',
-    body: JSON.stringify({ status }),
-  });
-}
-
-export function addSurveyTarget(campaignId: string, input: {
-  assetId: string;
-  assignedUserId?: string | null;
-  dueAt?: string | null;
-  instructions?: string | null;
-}) {
-  return apiRequest<SurveyCampaign>(`/survey-campaigns/${campaignId}/targets`, {
-    method: 'POST',
-    body: JSON.stringify(input),
-  });
-}
-
-export function updateSurveyTarget(id: string, input: {
-  dueAt?: string | null;
-  instructions?: string | null;
-}) {
-  return apiRequest<SurveyCampaign>(`/survey-campaign-targets/${id}`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export function assignSurveyTarget(id: string, assignedUserId: string | null) {
-  return apiRequest<SurveyCampaign>(`/survey-campaign-targets/${id}/assignment`, {
-    method: 'PUT',
-    body: JSON.stringify({ assignedUserId }),
-  });
-}
-
-export function updateSurveyTargetStatus(id: string, status: SurveyTargetStatus) {
-  return apiRequest<SurveyCampaign>(`/survey-campaign-targets/${id}/status`, {
-    method: 'PUT',
-    body: JSON.stringify({ status }),
-  });
-}
-
-export function getSurveyExecution(targetId: string) {
-  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report`);
-}
-
-export function saveSurveyReport(targetId: string, input: {
-  outcome: SurveyReportOutcome | null;
-  observedAt: string | null;
-  latitude: number | null;
-  longitude: number | null;
-  accuracyM: number | null;
-  notes: string | null;
-  mediaIds: string[];
-}) {
-  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report`, {
-    method: 'PUT',
-    body: JSON.stringify(input),
-  });
-}
-
-export function submitSurveyReport(targetId: string) {
-  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report/submit`, {
-    method: 'POST',
-  });
-}
-
-export function reviewSurveyReport(
-  targetId: string,
-  decision: 'APPROVE' | 'REJECT',
-  notes: string | null,
-) {
-  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report/review`, {
-    method: 'POST',
-    body: JSON.stringify({ decision, notes }),
-  });
-}
-
-export function listInspectionVisits(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  status?: InspectionVisitStatus | '';
-  companyId?: string;
-  areaId?: string;
-  inspectorId?: string;
-  dateFrom?: string;
-  dateTo?: string;
-}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.status) query.set('status', params.status);
-  if (params.companyId) query.set('companyId', params.companyId);
-  if (params.areaId) query.set('areaId', params.areaId);
-  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
-  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
-  if (params.dateTo) query.set('dateTo', params.dateTo);
-  return apiRequest<Page<InspectionVisitListItem>>(`/inspection-visits?${query}`);
-}
-
-export function getInspectionVisit(id: string) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}`);
-}
-
-export async function listInspectionAssignees() {
-  return (await apiRequest<{ data: InspectionPerson[] }>('/inspection-visits/assignees')).data;
-}
-
-export async function listInspectionPlanningAreas() {
-  return (await apiRequest<{ data: InspectionPlanningContextAsset[] }>('/inspection-visits/planning-context/areas')).data;
-}
-
-export async function listInspectionPlanningOperators(areaId: string) {
-  return (await apiRequest<{ data: InspectionPlanningContextAsset[] }>(`/inspection-visits/planning-context/areas/${areaId}/operators`)).data;
-}
-
-export function createInspectionVisit(input: {
-  operationalAreaId: string;
-  operatorCompanyId: string;
-  plannedStartAt: string;
-  leadInspectorUserId: string;
-}) {
-  return apiRequest<InspectionVisit>('/inspection-visits', {
-    method: 'POST',
-    body: JSON.stringify(input),
-  });
-}
-
-export function updateInspectionVisit(id: string, input: {
-  objective?: string | null;
-  scopeAssetId?: string | null;
-  operationalAreaId?: string | null;
-  operatorCompanyId?: string | null;
-  plannedStartAt?: string | null;
-  instructions?: string | null;
-}) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export function replaceInspectionVisitAssets(id: string, assetIds: string[]) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/assets`, {
-    method: 'PUT',
-    body: JSON.stringify({ assetIds }),
-  });
-}
-
-export function generateInspectionVisitChecklist(id: string) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/checklist/generate`, {
-    method: 'POST',
-  });
-}
-
-export function excludeInspectionVisitAsset(id: string, assetId: string, reason: string) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/assets/${assetId}/exclude`, {
-    method: 'POST',
-    body: JSON.stringify({ reason }),
-  });
-}
-
-export function includeInspectionVisitAsset(id: string, assetId: string) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/assets/${assetId}/include`, {
-    method: 'POST',
-  });
-}
-
-export function replaceInspectionVisitTeam(
-  id: string,
-  leadInspectorUserId: string | null,
-  memberUserIds: string[],
-) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/team`, {
-    method: 'PUT',
-    body: JSON.stringify({ leadInspectorUserId, memberUserIds }),
-  });
-}
-
-export function updateInspectionVisitStatus(
-  id: string,
-  status: InspectionVisitStatus,
-  reason?: string | null,
-) {
-  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/status`, {
-    method: 'PUT',
-    body: JSON.stringify({ status, reason: reason ?? null }),
-  });
-}
-
-export function listInspectionActs(visitId: string, params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  status?: InspectionActStatus | '';
-} = {}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.status) query.set('status', params.status);
-  return apiRequest<Page<InspectionActListItem>>(
-    `/inspection-visits/${visitId}/acts?${query}`,
-  );
-}
-
-export function listInspectionActsGlobal(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  status?: InspectionActStatus | '';
-  year?: number | '';
-  companyId?: string;
-  areaId?: string;
-  inspectorId?: string;
-  dateFrom?: string;
-  dateTo?: string;
-} = {}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.status) query.set('status', params.status);
-  if (params.year) query.set('year', String(params.year));
-  if (params.companyId) query.set('companyId', params.companyId);
-  if (params.areaId) query.set('areaId', params.areaId);
-  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
-  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
-  if (params.dateTo) query.set('dateTo', params.dateTo);
-  return apiRequest<Page<InspectionActListItem>>(`/inspection-acts?${query}`);
-}
-
-export function listInspectionReports(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  year?: number | '';
-  companyId?: string;
-  areaId?: string;
-  inspectorId?: string;
-  dateFrom?: string;
-  dateTo?: string;
-} = {}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.year) query.set('year', String(params.year));
-  if (params.companyId) query.set('companyId', params.companyId);
-  if (params.areaId) query.set('areaId', params.areaId);
-  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
-  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
-  if (params.dateTo) query.set('dateTo', params.dateTo);
-  return apiRequest<Page<InspectionReportListItem>>(`/inspection-reports?${query}`);
-}
-
-export function listPendingInspectionReports(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  year?: number | '';
-  companyId?: string;
-  areaId?: string;
-  inspectorId?: string;
-  dateFrom?: string;
-  dateTo?: string;
-} = {}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.year) query.set('year', String(params.year));
-  if (params.companyId) query.set('companyId', params.companyId);
-  if (params.areaId) query.set('areaId', params.areaId);
-  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
-  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
-  if (params.dateTo) query.set('dateTo', params.dateTo);
-  return apiRequest<Page<PendingInspectionReportItem>>(`/inspection-reports/pending?${query}`);
-}
-
-export function getInspectionReport(id: string) {
-  return apiRequest<InspectionReport>(`/inspection-reports/${id}`);
-}
-
-export function getInspectionReportReview(id: string) {
-  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review`);
-}
-
-export function uploadInspectionReportRevision(id: string, file: File, changeSummary: string) {
-  const form = new FormData();
-  form.append('file', file);
-  form.append('changeSummary', changeSummary);
-  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review/revisions`, { method: 'POST', body: form });
-}
-
-export function approveInspectionReport(id: string, note?: string) {
-  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review/approve`, { method: 'POST', body: JSON.stringify({ note: note?.trim() || undefined }) });
-}
-
-export function signFinalInspectionReport(id: string) {
-  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review/sign-final`, { method: 'POST', body: JSON.stringify({ confirmation: true }) });
-}
-
-export function inspectionReportRevisionUrl(revisionId: string) {
-  return `${API_BASE}/inspection-report-revisions/${revisionId}/content`;
-}
-
-export function getInspectionAct(id: string) {
-  return apiRequest<InspectionAct>(`/inspection-acts/${id}`);
-}
-
-export function getInspectionClosure(actId: string) {
-  return apiRequest<InspectionClosure>(`/inspection-acts/${actId}/closure`);
-}
-
-export function getInspectionSignatureBlob(signatureId: string) {
-  return apiBlobRequest(`/inspection-act-signatures/${signatureId}/content`);
-}
-
-export function getFindingCatalog(params: { categoryId?: string; search?: string } = {}) {
-  const query = new URLSearchParams();
-  if (params.categoryId) query.set('categoryId', params.categoryId);
-  if (params.search) query.set('search', params.search);
-  return apiRequest<FindingCatalog>(`/finding-catalog${query.size ? `?${query}` : ''}`);
-}
-
-export function getFindingCatalogAdmin() {
-  return apiRequest<FindingAdminCatalog>('/finding-catalog/admin');
-}
-
-export function getApplicableFindingCatalog(assetId: string, params: { categoryId?: string; search?: string } = {}) {
-  const query = new URLSearchParams();
-  if (params.categoryId) query.set('categoryId', params.categoryId);
-  if (params.search) query.set('search', params.search);
-  return apiRequest<FindingCatalogApplicable>(`/finding-catalog/applicable/${assetId}${query.size ? `?${query}` : ''}`);
-}
-
-export function getFindingCatalogAssetTypeSelection(assetTypeId: string) {
-  return apiRequest<FindingCatalogAssetTypeSelection>(`/finding-catalog/asset-types/${assetTypeId}/selection`);
-}
-
-export function replaceFindingCatalogAssetTypeSelection(assetTypeId: string, input: { enabledItemIds: string[]; reason: string }) {
-  return apiRequest<FindingCatalogAssetTypeSelection>(`/finding-catalog/asset-types/${assetTypeId}/selection`, {
-    method: 'PUT',
-    body: JSON.stringify(input),
-  });
-}
-
-export function getFindingCatalogAssetSelection(assetId: string) {
-  return apiRequest<FindingCatalogAssetSelection>(`/finding-catalog/assets/${assetId}/selection`);
-}
-
-export function replaceFindingCatalogAssetSelection(assetId: string, input: { enabledItemIds: string[]; reason: string }) {
-  return apiRequest<FindingCatalogAssetSelection>(`/finding-catalog/assets/${assetId}/selection`, {
-    method: 'PUT',
-    body: JSON.stringify(input),
-  });
-}
-
-export function listFindingCatalogProposals(params: { status?: FindingCatalogProposalStatus; assetTypeId?: string } = {}) {
-  const query = new URLSearchParams();
-  if (params.status) query.set('status', params.status);
-  if (params.assetTypeId) query.set('assetTypeId', params.assetTypeId);
-  return apiRequest<FindingCatalogProposal[]>(`/finding-catalog/proposals${query.size ? `?${query}` : ''}`);
-}
-
-export function reviewFindingCatalogProposal(id: string, input: {
-  decision: 'MATCH' | 'REJECT';
-  catalogItemId?: string;
-  notes?: string | null;
-}) {
-  return apiRequest<FindingCatalogProposal>(`/finding-catalog/proposals/${id}/review`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export function createFindingCategory(input: {
-  code: string;
-  name: string;
-  sortOrder: number;
-}) {
-  return apiRequest<FindingAdminCategory>('/finding-catalog/categories', {
-    method: 'POST',
-    body: JSON.stringify(input),
-  });
-}
-
-export function updateFindingCategory(id: string, input: {
-  name?: string;
-  sortOrder?: number;
-  isActive?: boolean;
-}) {
-  return apiRequest<FindingAdminCategory>(`/finding-catalog/categories/${id}`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export interface FindingCatalogItemInput {
-  categoryId: string;
-  sourceNumber: number;
-  title: string;
-  legalBasis?: string | null;
-  glossary?: string | null;
-  importNote?: string | null;
-  suggestedSeverity?: number | null;
-}
-
-export function createFindingCatalogItem(input: FindingCatalogItemInput & { code: string }) {
-  return apiRequest<FindingAdminCatalogItem>('/finding-catalog/items', {
-    method: 'POST',
-    body: JSON.stringify(input),
-  });
-}
-
-export function updateFindingCatalogItem(id: string, input: FindingCatalogItemInput & {
-  isActive: boolean;
-}) {
-  return apiRequest<FindingAdminCatalogItem>(`/finding-catalog/items/${id}`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export async function listInspectionFindings(actId: string) {
-  return (await apiRequest<{ data: InspectionFinding[] }>(
-    `/inspection-acts/${actId}/findings`,
-  )).data;
-}
-
-export function listInspectionFindingsGlobal(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  workflow?: InspectionFindingWorkflow;
-  companyId?: string;
-  areaId?: string;
-  inspectorId?: string;
-  dateFrom?: string;
-  dateTo?: string;
-} = {}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 25),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.workflow) query.set('workflow', params.workflow);
-  if (params.companyId) query.set('companyId', params.companyId);
-  if (params.areaId) query.set('areaId', params.areaId);
-  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
-  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
-  if (params.dateTo) query.set('dateTo', params.dateTo);
-  return apiRequest<InspectionFindingGlobalPage>(`/inspection-findings?${query}`);
-}
-
-export function getInspectionFinding(id: string) {
-  return apiRequest<InspectionFinding>(`/inspection-findings/${id}`);
-}
-
-export function getInspectionFindingVerificationHistory(id: string) {
-  return apiRequest<InspectionFindingVerificationEvent[]>(`/inspection-findings/${id}/verification-history`);
-}
-
-export function listVerificationPlanning(params: {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  planningStatus?: VerificationPlanningStatus;
-  companyId?: string;
-  areaId?: string;
-  dueFrom?: string;
-  dueTo?: string;
-} = {}) {
-  const query = new URLSearchParams({
-    page: String(params.page ?? 1),
-    pageSize: String(params.pageSize ?? 50),
-  });
-  if (params.search) query.set('search', params.search);
-  if (params.planningStatus) query.set('planningStatus', params.planningStatus);
-  if (params.companyId) query.set('companyId', params.companyId);
-  if (params.areaId) query.set('areaId', params.areaId);
-  if (params.dueFrom) query.set('dueFrom', params.dueFrom);
-  if (params.dueTo) query.set('dueTo', params.dueTo);
-  return apiRequest<VerificationPlanningPage>(`/inspection-verifications?${query}`);
-}
-
-export function planVerificationVisit(input: {
-  findingIds: string[];
-  plannedStartAt: string;
-  notes?: string | null;
-}) {
-  return apiRequest<PlannedVerificationVisitResult>('/inspection-verifications/plan', {
-    method: 'POST',
-    body: JSON.stringify(input),
-  });
-}
-
-export function recordVerificationResult(visitId: string, findingId: string, input: {
-  outcome: InspectionVerificationOutcome;
-  notes: string;
-  verifiedAt?: string;
-  nextControlOn?: string;
-}) {
-  return apiRequest<{
-    findingId: string;
-    visitId: string;
-    targetControlOn: string | null;
-    outcome: InspectionVerificationOutcome;
-    notes: string;
-    verifiedAt: string;
-    recordedAt: string;
-    rescheduledControlOn: string | null;
-    nextControlOn: string | null;
-    findingStatus: InspectionFindingStatus;
-    visitStatus: InspectionVisitStatus;
-  }>(`/inspection-verifications/visits/${visitId}/findings/${findingId}/result`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export function closeInspectionFinding(id: string, closureNotes: string) {
-  return apiRequest<InspectionFinding>(`/inspection-findings/${id}/close`, {
-    method: 'PATCH',
-    body: JSON.stringify({ closureNotes }),
-  });
-}
-
-export function updateInspectionFindingFollowUp(id: string, input: {
-  responseDueBasis?: 'FINDING_DATE' | 'REPORT_NOTIFICATION' | null;
-  responseDueDays?: number | null;
-  reportNotifiedOn?: string | null;
-  companyResponse?: string | null;
-  companyResponseReceivedOn?: string | null;
-  companyCommittedCorrectionOn?: string | null;
-  nextControlOn?: string | null;
-}) {
-  return apiRequest<InspectionFinding>(`/inspection-findings/${id}/follow-up`, {
-    method: 'PATCH',
-    body: JSON.stringify(input),
-  });
-}
-
-export async function listInspectionFindingEvidence(findingId: string) {
-  return (await apiRequest<{ data: InspectionFindingEvidence[] }>(
-    `/inspection-findings/${findingId}/evidence`,
-  )).data;
-}
-
-export function uploadInspectionFindingEvidence(findingId: string, input: {
-  file: File;
-  kind: InspectionEvidenceKind;
-  purpose: InspectionEvidencePurpose;
-  communicationId?: string;
-  verificationVisitId?: string;
-  title?: string;
-  description?: string;
-  capturedAt?: string;
-  latitude?: number;
-  longitude?: number;
-  accuracyM?: number;
-  deviceLabel?: string;
-}) {
-  const body = new FormData();
-  body.append('file', input.file);
-  body.append('kind', input.kind);
-  body.append('purpose', input.purpose);
-  if (input.communicationId) body.append('communicationId', input.communicationId);
-  if (input.verificationVisitId) body.append('verificationVisitId', input.verificationVisitId);
-  if (input.title) body.append('title', input.title);
-  if (input.description) body.append('description', input.description);
-  if (input.capturedAt) body.append('capturedAt', input.capturedAt);
-  if (input.latitude !== undefined) body.append('latitude', String(input.latitude));
-  if (input.longitude !== undefined) body.append('longitude', String(input.longitude));
-  if (input.accuracyM !== undefined) body.append('accuracyM', String(input.accuracyM));
-  if (input.deviceLabel) body.append('deviceLabel', input.deviceLabel);
-  return apiRequest<InspectionFindingEvidence>(
-    `/inspection-findings/${findingId}/evidence`,
-    { method: 'POST', body },
-  );
-}
-
-export function getInspectionFindingEvidenceBlob(evidenceId: string, download = false) {
-  return apiBlobRequest(
-    `/inspection-finding-evidence/${evidenceId}/content${download ? '?download=1' : ''}`,
-  );
-}
-
-export async function listInspectionFindingCommunications(findingId: string) {
-  return (await apiRequest<{ data: InspectionFindingCommunication[] }>(
-    `/inspection-findings/${findingId}/communications`,
-  )).data;
-}
-
-export function createInspectionFindingCommunication(findingId: string, input: {
-  direction: InspectionFindingCommunication['direction'];
-  channel: InspectionFindingCommunication['channel'];
-  type: InspectionFindingCommunication['type'];
-  occurredAt: string;
-  subject: string;
-  details?: string | null;
-  contactName?: string | null;
-  contactEmail?: string | null;
-}) {
-  return apiRequest<InspectionFindingCommunication>(
-    `/inspection-findings/${findingId}/communications`,
-    { method: 'POST', body: JSON.stringify(input) },
-  );
-}
-
-export function listAssetImportBatches(params: { page?: number; pageSize?: number; status?: AssetImportBatchStatus | '' } = {}) {
-  const query = new URLSearchParams({ page: String(params.page ?? 1), pageSize: String(params.pageSize ?? 20) });
-  if (params.status) query.set('status', params.status);
-  return apiRequest<Page<AssetImportBatch>>(`/asset-imports?${query}`);
-}
-
-export function listAssetImportReviews(params: { page?: number; pageSize?: number; kind?: 'ALL' | 'DIRECT' | 'DEPENDENCY' } = {}) {
-  const query = new URLSearchParams();
-  if (params.page) query.set('page', String(params.page));
-  if (params.pageSize) query.set('pageSize', String(params.pageSize));
-  if (params.kind && params.kind !== 'ALL') query.set('kind', params.kind);
-  const suffix = query.toString() ? `?${query}` : '';
-  return apiRequest<{ data: AssetImportReviewItem[]; meta: { page: number; pageSize: number; total: number; totalPages: number } }>(`/asset-imports/reviews${suffix}`);
-}
-
-export function getAssetImportBatch(id: string) {
-  return apiRequest<AssetImportBatchDetail>(`/asset-imports/${id}`);
-}
-
-export function listAssetImportRows(id: string, params: { page?: number; pageSize?: number; status?: AssetImportRowStatus | ''; search?: string } = {}) {
-  const query = new URLSearchParams({ page: String(params.page ?? 1), pageSize: String(params.pageSize ?? 50) });
-  if (params.status) query.set('status', params.status);
-  if (params.search) query.set('search', params.search);
-  return apiRequest<Page<AssetImportRow>>(`/asset-imports/${id}/rows?${query}`);
-}
-
-export function uploadAssetImport(input: { file: File; sourceLabel?: string; notes?: string; profileCode?: Exclude<AssetImportProfileCode, 'UNKNOWN'> }) {
-  const body = new FormData();
-  body.append('file', input.file);
-  if (input.sourceLabel?.trim()) body.append('sourceLabel', input.sourceLabel.trim());
-  if (input.notes?.trim()) body.append('notes', input.notes.trim());
-  if (input.profileCode) body.append('profileCode', input.profileCode);
-  return apiRequest<AssetImportBatch>('/asset-imports', { method: 'POST', body });
-}
-
-export function reconcileAssetImport(id: string) {
-  return apiRequest<AssetImportBatch>(`/asset-imports/${id}/reconcile`, { method: 'POST' });
-}
-
-export function listAssetImportOrganizations(search?: string) {
-  const query = new URLSearchParams();
-  if (search?.trim()) query.set('search', search.trim());
-  const suffix = query.toString() ? `?${query}` : '';
-  return apiRequest<{ data: AssetImportOrganizationOption[] }>(`/asset-imports/context/organizations${suffix}`);
-}
-
-export function getAssetImportPlan(id: string) {
-  return apiRequest<AssetImportPlan | null>(`/asset-imports/${id}/plan`);
-}
-
-export function generateAssetImportPlan(id: string, input: { operatorAssetId?: string; externalIdNamespace?: string }) {
-  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/plan`, { method: 'POST', body: JSON.stringify(input) });
-}
-
-export function listAssetImportPlanItems(id: string, input: { entityKind?: AssetImportPlanEntityKind; action?: AssetImportPlanAction; page?: number; pageSize?: number } = {}) {
-  const query = new URLSearchParams();
-  if (input.entityKind) query.set('entityKind', input.entityKind);
-  if (input.action) query.set('action', input.action);
-  if (input.page) query.set('page', String(input.page));
-  if (input.pageSize) query.set('pageSize', String(input.pageSize));
-  const suffix = query.toString() ? `?${query}` : '';
-  return apiRequest<{ data: AssetImportPlanItem[]; meta: { page: number; pageSize: number; total: number; totalPages: number } }>(`/asset-imports/${id}/plan/items${suffix}`);
-}
-
-export function resolveAssetImportPlanItem(id: string, itemId: string, input: { action: 'CREATE' | 'MATCH' | 'IGNORE'; matchedAssetId?: string; reason: string }) {
-  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/plan/items/${itemId}/resolve`, { method: 'POST', body: JSON.stringify(input) });
-}
-
-export function applySafeAssetImportPlan(id: string, planHash: string) {
-  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/apply-safe`, { method: 'POST', body: JSON.stringify({ planHash }) });
-}
-
-export function applyAssetImportPlan(id: string, planHash: string) {
-  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/apply`, { method: 'POST', body: JSON.stringify({ planHash }) });
-}
-
-export function rollbackAssetImportPlan(id: string, reason: string) {
-  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/rollback`, { method: 'POST', body: JSON.stringify({ reason }) });
-}
-
-export function cancelAssetImport(id: string, reason: string) {
-  return apiRequest<AssetImportBatch>(`/asset-imports/${id}/cancel`, { method: 'POST', body: JSON.stringify({ reason }) });
-}
-
-
-export function inspectionReportWordUrl(id: string) {
-  return `${API_BASE}/inspection-reports/${id}/word`;
-}
-
-export function generateInspectionReportWord(id: string) {
-  return apiRequest<InspectionReport>(`/inspection-reports/${id}/word`, { method: 'POST' });
-}
-
-
-export interface DocumentDeliverySettings { officeEmail:string|null; directorEmail:string|null; updatedAt:string; smtpConfigured:boolean; mailFrom:string|null; }
-export interface DocumentDeliveryItem { id:string; actId:string; reportId:string|null; documentKind:'ACT_PDF'|'REPORT_WORD'; recipientKind:'COMPANY'|'OFFICE'|'DIRECTOR'; recipientAssetId:string|null; recipientAssetName:string|null; recipientEmail:string|null; status:'PENDING'|'WAITING_RECIPIENT'|'WAITING_TRANSPORT'|'WAITING_ARTIFACT'|'SENT'|'FAILED'; attempts:number; lastAttemptAt:string|null; sentAt:string|null; providerMessageId:string|null; lastError:string|null; createdAt:string; actCode:string; reportCode:string|null; }
-export function getDocumentDeliverySettings(){return apiRequest<DocumentDeliverySettings>('/document-delivery/settings');}
-export function updateDocumentDeliverySettings(input:{officeEmail?:string|null;directorEmail?:string|null}){return apiRequest<DocumentDeliverySettings>('/document-delivery/settings',{method:'PATCH',body:JSON.stringify(input)});}
-export function listDocumentDeliveries(){return apiRequest<{data:DocumentDeliveryItem[]}>('/document-delivery/outbox');}
-export function retryDocumentDelivery(id:string){return apiRequest<DocumentDeliveryItem>(`/document-delivery/outbox/${id}/retry`,{method:'POST'});}
-export function retryPendingDocumentDeliveries(){return apiRequest<{processed:number}>('/document-delivery/outbox/retry-pending',{method:'POST'});}
-
-export type ActAdministrationState = 'NEW' | 'WAITING_RESPONSE' | 'DUE_SOON' | 'OVERDUE' | 'RESPONSE_RECEIVED' | 'VERIFICATION_PENDING' | 'COMMITMENT_OVERDUE' | 'REGULARIZED';
-export interface ActAdministrationQueueItem {
-  actId: string; actCode: string; actStatus: string; occurredAt: string; closedAt: string | null;
-  visitId: string; visitCode: string; areaId: string | null; companyId: string | null; areaName: string | null; companyName: string | null;
-  responseDueOn: string | null; deadlineReason: string | null; responseReceivedOn: string | null; committedCorrectionOn: string | null;
-  findingCount: number; openFindingCount: number; scheduledControlCount: number; adminState: ActAdministrationState;
-}
-export interface ActAdministrationQueuePage { data: ActAdministrationQueueItem[]; counters: Partial<Record<ActAdministrationState, number>>; meta: PageMeta }
-export interface ActAdministrationDetail {
-  act: ActAdministrationQueueItem;
-  deadlines: Array<{ id:string; responseDueOn:string; reason:string; createdAt:string }>;
-  responses: Array<{ id:string; receivedOn:string; details:string|null; committedCorrectionOn:string|null; contactName:string|null; contactEmail:string|null; originalName:string|null; sizeBytes:number|null; sha256:string|null; createdAt:string }>;
-  findings: Array<{ id:string; code:string; title:string; status:string; nextControlOn:string|null }>;
-}
-export function listActAdministrationQueue(params: { state?: ActAdministrationState | 'ALL'; areaId?: string; companyId?: string; page?: number; pageSize?: number } = {}) {
-  const q = new URLSearchParams({ page: String(params.page ?? 1), pageSize: String(params.pageSize ?? 25) });
-  if (params.state && params.state !== 'ALL') q.set('state', params.state);
-  if (params.areaId) q.set('areaId', params.areaId);
-  if (params.companyId) q.set('companyId', params.companyId);
-  return apiRequest<ActAdministrationQueuePage>(`/act-administration/queue?${q}`);
-}
-export function getActAdministration(actId: string) { return apiRequest<ActAdministrationDetail>(`/inspection-acts/${actId}/administration`); }
-export function setActResponseDeadline(actId: string, input: { responseDueOn: string; reason: string }) { return apiRequest(`/inspection-acts/${actId}/administration/deadline`, { method: 'PATCH', body: JSON.stringify(input) }); }
-export function addActCompanyResponse(actId: string, input: { receivedOn: string; details?: string; committedCorrectionOn?: string; contactName?: string; contactEmail?: string; file?: File }) {
-  const body = new FormData(); body.append('receivedOn', input.receivedOn);
-  if (input.details) body.append('details', input.details); if (input.committedCorrectionOn) body.append('committedCorrectionOn', input.committedCorrectionOn);
-  if (input.contactName) body.append('contactName', input.contactName); if (input.contactEmail) body.append('contactEmail', input.contactEmail); if (input.file) body.append('file', input.file);
-  return apiRequest(`/inspection-acts/${actId}/administration/responses`, { method: 'POST', body });
-}
-export function actCompanyResponseContentUrl(responseId: string) { return `${API_BASE}/act-company-responses/${responseId}/content`; }
-export function listActAdministrationCalendar(from?: string, to?: string) { const q=new URLSearchParams(); if(from)q.set('from',from); if(to)q.set('to',to); return apiRequest<{from:string;to:string;data:Array<{type:'RESPONSE_DUE'|'COMMITMENT_DUE';date:string;actId:string;actCode:string;areaName:string|null;companyName:string|null;state:ActAdministrationState}>}>(`/act-administration/calendar${q.size?`?${q}`:''}`); }
-
+placeholder
\ No newline at end of file

From 116dd24b7b5eb332f0e28e071028f6cb71eefd3a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:28:19 -0300
Subject: [PATCH 130/224] F4: remove accidental api placeholder before exact
 restore

---
 web-v2/src/lib/api.ts | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 web-v2/src/lib/api.ts

diff --git a/web-v2/src/lib/api.ts b/web-v2/src/lib/api.ts
deleted file mode 100644
index b3a4252..0000000
--- a/web-v2/src/lib/api.ts
+++ /dev/null
@@ -1 +0,0 @@
-placeholder
\ No newline at end of file

From e3c347dbb803927d27d826573b40fb81a444638d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:32:48 -0300
Subject: [PATCH 131/224] F4: restore web API client exactly after accidental
 overwrite

---
 web-v2/src/lib/api.ts | 3131 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 3131 insertions(+)
 create mode 100644 web-v2/src/lib/api.ts

diff --git a/web-v2/src/lib/api.ts b/web-v2/src/lib/api.ts
new file mode 100644
index 0000000..d4885d2
--- /dev/null
+++ b/web-v2/src/lib/api.ts
@@ -0,0 +1,3131 @@
+const API_BASE = '/api/v3';
+
+export class ApiError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly code: string,
+    message: string,
+    public readonly requestId?: string,
+  ) {
+    super(message);
+    this.name = 'ApiError';
+  }
+}
+
+export interface AuthUser {
+  id: string;
+  username: string;
+  firstName: string;
+  lastName: string;
+  email: string | null;
+  mustChangePassword: boolean;
+  roles: string[];
+  permissions: string[];
+}
+
+export interface AuthResponse {
+  user: AuthUser;
+  csrfToken: string;
+  accessExpiresInSeconds: number;
+}
+
+export interface HealthResponse {
+  status: string;
+  service: string;
+  api: string;
+  version: string;
+  phase: string;
+  database: string;
+  time: string;
+  latencyMs: number;
+}
+
+export interface DashboardSummary {
+  counts: {
+    totalAssets: number;
+    assetsNeedValidation: number;
+    assetsWithoutGeometry: number;
+    plannedInspections: number;
+    activeUsers: number;
+    inactiveUsers: number;
+    activeSessions: number;
+    openFindings: number;
+    awaitingCompanyResponse: number;
+    overdueCompanyResponses: number;
+    companyResponsesDueNext7Days: number;
+    awaitingVerificationSchedule: number;
+    overdueControls: number;
+    controlsNext30Days: number;
+  };
+  recentAudit: Array<{
+    id: string;
+    occurredAt: string;
+    actorUsername: string | null;
+    action: string;
+    entityType: string | null;
+    entityId: string | null;
+  }>;
+  upcomingControls: Array<{
+    id: string;
+    code: string;
+    title: string;
+    nextControlOn: string;
+    actId: string;
+    actCode: string;
+    visitId: string;
+    visitCode: string;
+    assetId: string;
+    assetCode: string;
+    assetName: string;
+  }>;
+  generatedAt: string;
+}
+
+export interface RoleSummary { id: string; code: string; name: string }
+
+export interface AdministrativeUser {
+  id: string;
+  username: string;
+  email: string | null;
+  firstName: string;
+  lastName: string;
+  status: 'ACTIVE' | 'INACTIVE';
+  mustChangePassword: boolean;
+  failedLoginAttempts: number;
+  lockedUntil: string | null;
+  lastLoginAt: string | null;
+  passwordChangedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+  roles: RoleSummary[];
+}
+
+export interface Permission { id: string; code: string; description: string }
+
+export interface AdministrativeRole {
+  id: string;
+  code: string;
+  name: string;
+  description: string;
+  isSystem: boolean;
+  createdAt: string;
+  updatedAt: string;
+  userCount: number;
+  permissions: Permission[];
+}
+
+export interface AuditEventSummary {
+  id: string;
+  occurredAt: string;
+  actorUserId: string | null;
+  actorUsername: string | null;
+  action: string;
+  entityType: string | null;
+  entityId: string | null;
+  requestId: string | null;
+  source: 'WEB' | 'ANDROID' | 'SYSTEM' | 'IMPORT';
+  ip: string | null;
+  hasDetails: boolean;
+}
+
+export interface AuditEventDetail extends AuditEventSummary {
+  userAgent: string | null;
+  beforeData: Record<string, unknown> | null;
+  afterData: Record<string, unknown> | null;
+  metadata: Record<string, unknown> | null;
+}
+
+export interface PageMeta { page: number; pageSize: number; total: number; totalPages: number }
+interface Page<T> { data: T[]; meta: PageMeta }
+
+export type AssetInformationStatus =
+  | 'DRAFT' | 'PENDING_SURVEY' | 'SURVEYED' | 'VALIDATED'
+  | 'OBSERVED' | 'OUTDATED' | 'INACTIVE';
+
+export type AssetOperationalStatus =
+  | 'UNKNOWN' | 'IN_SERVICE' | 'TEMPORARILY_OUT_OF_SERVICE'
+  | 'OUT_OF_SERVICE' | 'DECOMMISSIONED' | 'ABANDONED';
+
+export type AssetDataOrigin =
+  | 'MANUAL' | 'FIELD_SURVEY' | 'PROVIDED_DOCUMENT' | 'IMPORT' | 'SYSTEM';
+
+export type AssetTypeOperationalRole = 'GENERIC' | 'AREA' | 'COMPANY';
+
+export interface AssetProvenance {
+  assetId: string;
+  origin: AssetDataOrigin;
+  sourceName: string | null;
+  sourceReference: string | null;
+  observedAt: string | null;
+  notes: string | null;
+  verifiedAt: string | null;
+  verifiedBy: string | null;
+  verifiedByUsername: string | null;
+  updatedAt: string;
+  updatedBy: string | null;
+  updatedByUsername: string | null;
+}
+
+export type AssetAttributeDataType =
+  | 'TEXT' | 'NUMBER' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'SELECT';
+
+export interface AssetAttributeDefinition {
+  id: string;
+  code: string;
+  name: string;
+  dataType: AssetAttributeDataType;
+  isRequired: boolean;
+  isActive: boolean;
+  unit: string | null;
+  options: string[] | null;
+  sortOrder: number;
+}
+
+export interface AssetTypeSummary {
+  id: string;
+  code: string;
+  name: string;
+  isActive: boolean;
+  operationalRole: AssetTypeOperationalRole;
+}
+
+export interface AssetType extends AssetTypeSummary {
+  description: string;
+  canBeRoot: boolean;
+  createdAt: string;
+  updatedAt: string;
+  assetCount: number;
+  allowedParentTypes: AssetTypeSummary[];
+  attributes: AssetAttributeDefinition[];
+}
+
+export interface MasterBootstrapStatus {
+  presetCode: string;
+  presetName: string;
+  typeCount: number;
+  canApply: boolean;
+  reason: string | null;
+  types: Array<{
+    code: string;
+    name: string;
+    operationalRole: AssetTypeOperationalRole;
+    parentCodes: string[];
+    attributeCount: number;
+  }>;
+}
+
+export interface MasterBootstrapResult {
+  presetCode: string;
+  presetName: string;
+  createdTypeCount: number;
+  createdAttributeCount: number;
+  createdParentRuleCount: number;
+  data: AssetType[];
+}
+
+export interface MasterEnrichmentStatus {
+  presetCode: string;
+  presetName: string;
+  typeCount: number;
+  canApply: boolean;
+  complete: boolean;
+  reason: string | null;
+  missingTypeCodes: string[];
+  missingAttributeCount: number;
+  missingParentRuleCount: number;
+}
+
+export interface AssetListItem {
+  id: string;
+  code: string;
+  name: string;
+  commonName: string | null;
+  type: { id: string; code: string; name: string };
+  parent: { id: string; code: string; name: string } | null;
+  operationalArea: { id: string; code: string; name: string } | null;
+  operatorCompany: { id: string; code: string; name: string } | null;
+  informationStatus: AssetInformationStatus;
+  operationalStatus: AssetOperationalStatus;
+  childrenCount: number;
+  hasGeometry: boolean;
+  geometryType: AssetGeometryType | null;
+  mediaCount: number;
+  dataOrigin: AssetDataOrigin;
+  provenanceVerified: boolean;
+  currentVersion: number;
+  updatedAt: string;
+}
+
+export interface AssetLineageItem {
+  id: string;
+  code: string;
+  name: string;
+  commonName: string | null;
+  type: { id: string; code: string; name: string };
+}
+
+export interface AssetDetail extends AssetListItem {
+  description: string | null;
+  createdAt: string;
+  createdBy: string | null;
+  updatedBy: string | null;
+  attributes: Array<{
+    definitionId: string;
+    code: string;
+    name: string;
+    dataType: AssetAttributeDataType;
+    isRequired: boolean;
+    unit: string | null;
+    options: string[] | null;
+    sortOrder: number;
+    value: unknown;
+  }>;
+}
+
+export type AssetDossierTimelineKind =
+  | 'INVENTORY_CHANGE' | 'INSPECTION' | 'ACT' | 'FINDING' | 'FINDING_CLOSED'
+  | 'COMMUNICATION' | 'PHOTO' | 'DOCUMENT' | 'REPORT' | 'SOURCE_DOCUMENT' | 'VERIFICATION';
+
+export interface AssetDossierTimelineEvent {
+  id: string;
+  kind: AssetDossierTimelineKind;
+  occurredAt: string;
+  title: string;
+  description: string | null;
+  href?: string;
+  meta?: Record<string, unknown>;
+}
+
+export interface AssetDossier {
+  asset: { id: string; code: string; name: string; commonName: string | null };
+  counters: {
+    inspections: number; acts: number; findings: number; openFindings: number; closedFindings: number;
+    evidence: number; documents: number; photos: number; reports: number; verifications: number;
+  };
+  visits: Array<{ id: string; code: string; title: string; status: InspectionVisitStatus; plannedStartAt: string | null; actualStartedAt: string | null; actualClosedAt: string | null; createdAt: string }>;
+  acts: Array<{ id: string; visitId: string; code: string; status: InspectionActStatus; occurredAt: string; title: string; summary: string; closedAt: string | null; currentVersion: number; visitCode: string; visitTitle: string }>;
+  findings: Array<{ id: string; actId: string; code: string; status: InspectionFindingStatus; title: string; description: string; correctionDueOn: string | null; companyResponseReceivedOn: string | null; nextControlOn: string | null; closedAt: string | null; closureNotes: string | null; createdAt: string; updatedAt: string; actCode: string; actOccurredAt: string; visitId: string; visitCode: string; visitTitle: string }>;
+  evidence: Array<{ id: string; findingId: string; communicationId: string | null; kind: InspectionEvidenceKind; purpose: InspectionEvidencePurpose; originalName: string; title: string | null; description: string | null; capturedAt: string | null; createdAt: string; findingCode: string; findingTitle: string }>;
+  communications: Array<{ id: string; findingId: string; direction: InspectionFindingCommunication['direction']; channel: InspectionFindingCommunication['channel']; type: InspectionFindingCommunication['type']; occurredAt: string; subject: string; details: string | null; contactName: string | null; createdAt: string; findingCode: string; findingTitle: string }>;
+  verificationResults: Array<{ id: string; findingId: string; findingCode: string; findingTitle: string; visitId: string; visitCode: string; visitTitle: string; visitStatus: InspectionVisitStatus; targetControlOn: string | null; outcome: InspectionVerificationOutcome | null; resultNotes: string | null; verifiedAt: string | null; resultRecordedAt: string | null; rescheduledControlOn: string | null; evidenceCount: number }>;
+  documents: Array<{ id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string; issuer: string | null; documentDate: string | null; externalReference: string | null; relationType: AssetSourceDocumentRelationType; notes: string | null; linkedAt: string }>;
+  inspectionReports: Array<{ id: string; code: string; status: InspectionReportStatus; pdfStatus: InspectionReportPdfStatus; title: string; generatedAt: string; frozenSha256: string; actId: string; actCode: string; visitId: string; visitCode: string }>;
+  reports: Array<{ id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string; issuer: string | null; documentDate: string | null; externalReference: string | null; relationType: AssetSourceDocumentRelationType; notes: string | null; linkedAt: string }>;
+  media: Array<{ id: string; kind: AssetMediaKind; originalName: string; title: string | null; description: string | null; capturedAt: string | null; createdAt: string; source: 'WEB' | 'ANDROID' | 'IMPORT' }>;
+  versions: Array<{ id: string; versionNumber: number; changeType: AssetVersionChangeType; changedFields: string[]; occurredAt: string; actorUsername: string | null; source: string }>;
+  timeline: AssetDossierTimelineEvent[];
+}
+
+export interface AssetContextHistoryItem {
+  id: string;
+  assetId: string;
+  validFrom: string;
+  validUntil: string | null;
+  changeReason: string;
+  endReason: string | null;
+  assetVersionNumber: number;
+  source: string;
+  requestId: string | null;
+  createdAt: string;
+  parent: { id: string; code: string; name: string } | null;
+  operationalArea: { id: string; code: string; name: string } | null;
+  operatorCompany: { id: string; code: string; name: string } | null;
+  creator: { id: string; username: string; firstName: string; lastName: string } | null;
+  isCurrent: boolean;
+}
+
+export type FieldDiscoveryStatus = 'PENDING' | 'APPROVED' | 'MATCHED' | 'REJECTED';
+
+export interface FieldDiscovery {
+  id: string;
+  status: FieldDiscoveryStatus;
+  discoveryNotes: string | null;
+  observedAt: string;
+  reviewedAt: string | null;
+  reviewNotes: string | null;
+  createdAt: string;
+  asset: {
+    id: string; code: string; name: string; commonName: string | null; informationStatus: AssetInformationStatus;
+    typeId: string; typeName: string; parentId: string | null; operationalAreaId: string | null; operatorCompanyId: string | null;
+  };
+  visit: { id: string; code: string; title: string; status: InspectionVisitStatus };
+  creator: { id: string; username: string; firstName: string; lastName: string };
+  reviewer: { id: string; username: string; firstName: string; lastName: string } | null;
+  matchedAsset: { id: string; code: string; name: string; commonName: string | null } | null;
+}
+
+export interface OperationalAssetSummary {
+  id: string;
+  code: string;
+  name: string;
+  commonName: string | null;
+  typeName: string;
+}
+
+export type AreaOrganizationRole = 'OPERATOR' | 'TECHNICAL_OPERATOR' | 'CONCESSIONAIRE' | 'PERMIT_HOLDER' | 'PARTICIPANT' | 'OTHER';
+
+export interface AreaCompanyRelation {
+  id: string;
+  area: OperationalAssetSummary;
+  company: OperationalAssetSummary;
+  relationRole: AreaOrganizationRole;
+  participationPercent: number | null;
+  legalInstrument: string | null;
+  sourceDocumentId: string | null;
+  validFrom: string;
+  validUntil: string | null;
+  startReason: string;
+  endReason: string | null;
+  createdBy: { id: string; username: string } | null;
+  endedBy: { id: string; username: string } | null;
+  createdAt: string;
+  updatedAt: string;
+  active: boolean;
+  assignedAssetCount: number;
+}
+
+
+export type OrganizationKind = 'COMPANY' | 'UTE' | 'PUBLIC_ENTITY' | 'OTHER';
+export type SourceDocumentType = 'NOTE' | 'TECHNICAL_REPORT' | 'INSPECTION_ACT' | 'INVENTORY' | 'RESOLUTION' | 'DECREE' | 'CONTRACT' | 'SPREADSHEET' | 'OTHER';
+export type AssetSourceDocumentRelationType = 'SOURCE' | 'MENTIONS' | 'VALIDATES' | 'SUPERSEDES' | 'OTHER';
+export type OrganizationMembershipRole = 'MEMBER' | 'LEAD_MEMBER' | 'OTHER';
+export type AreaLegalRightType = 'EXPLOITATION_CONCESSION' | 'EXPLORATION_PERMIT' | 'TRANSPORT_CONCESSION' | 'OTHER';
+export type AreaLegalRightStatus = 'ACTIVE' | 'EXPIRED' | 'REVOKED' | 'PENDING';
+export type AreaLegalRightOrganizationRole = 'HOLDER' | 'PARTICIPANT' | 'OPERATOR' | 'OTHER';
+
+export interface SourceDocumentSummary {
+  id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string;
+  issuer: string | null; documentDate: string | null; externalReference: string | null; notes: string | null;
+  createdAt?: string; updatedAt?: string;
+}
+export interface AssetRegistry {
+  organizationProfile: null | { assetId: string; organizationKind: OrganizationKind; legalName: string | null; taxId: string | null; notificationEmail: string | null; notes: string | null; createdAt: string; updatedAt: string };
+  organizationMemberships: Array<{ id: string; parent: { id: string; code: string; name: string }; member: { id: string; code: string; name: string }; role: OrganizationMembershipRole; participationPercent: number | null; validFrom: string; validUntil: string | null; sourceDocumentId: string | null; notes: string | null; endReason: string | null }>;
+  externalIdentifiers: Array<{ id: string; namespace: string; value: string; validFrom: string; validUntil: string | null; sourceDocumentId: string | null; notes: string | null; endReason: string | null }>;
+  sourceDocuments: Array<SourceDocumentSummary & { linkId: string; relationType: AssetSourceDocumentRelationType; linkNotes: string | null }>;
+  legalRights: Array<{ id: string; rightType: AreaLegalRightType; name: string; instrumentNumber: string | null; validFrom: string | null; validUntil: string | null; status: AreaLegalRightStatus; sourceDocumentId: string | null; notes: string | null; organizations: Array<{ id: string; organizationId: string; organizationName: string; role: AreaLegalRightOrganizationRole; participationPercent: number | null; validFrom: string; validUntil: string | null; notes: string | null; endReason: string | null }> }>;
+}
+
+
+export type AssetImportBatchStatus = 'ANALYZED' | 'REVIEW_REQUIRED' | 'CANCELLED' | 'FAILED';
+export type AssetImportRowStatus = 'READY' | 'WARNING' | 'CONFLICT' | 'IGNORED';
+export type AssetImportProfileCode = 'MENDOZA_INVENTORY_V1' | 'MENDOZA_YACIMIENTOS_V1' | 'UNKNOWN';
+
+export interface AssetImportBatch {
+  id: string;
+  originalName: string;
+  mimeType: string;
+  sizeBytes: number;
+  sha256: string;
+  profileCode: AssetImportProfileCode;
+  profileConfidence: number;
+  worksheetName: string | null;
+  headerRow: number | null;
+  totalRows: number;
+  readyRows: number;
+  warningRows: number;
+  conflictRows: number;
+  ignoredRows: number;
+  status: AssetImportBatchStatus;
+  sourceDocumentId: string | null;
+  sourceLabel: string | null;
+  notes: string | null;
+  analysis: Record<string, unknown>;
+  uploadedBy: string | null;
+  uploadedByUsername: string | null;
+  analyzedAt: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AssetImportBatchDetail extends AssetImportBatch {
+  topIssues: Array<{ code: string; count: number }>;
+  duplicateFiles: Array<{ id: string; originalName: string; createdAt: string; status: AssetImportBatchStatus }>;
+}
+
+export interface AssetImportRow {
+  id: string;
+  worksheetName: string;
+  rowNumber: number;
+  status: AssetImportRowStatus;
+  suggestedAction: 'CREATE' | 'MATCH' | 'REVIEW' | 'IGNORE';
+  rawData: Record<string, unknown>;
+  normalizedData: Record<string, unknown>;
+  issues: string[];
+  fingerprint: string;
+  matchedAssetId: string | null;
+  importedAssetId: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export type AssetImportPlanStatus = 'REVIEW_REQUIRED' | 'READY' | 'APPLIED' | 'ROLLED_BACK' | 'SUPERSEDED' | 'FAILED';
+export type AssetImportPlanEntityKind = 'DEPARTMENT' | 'ORGANIZATION' | 'AREA' | 'AREA_DEPARTMENT_RELATION' | 'FIELD' | 'OPERATOR_RELATION' | 'LEGAL_RIGHT' | 'LEGAL_RIGHT_ORGANIZATION' | 'INSTALLATION' | 'LOCAL_STRUCTURE' | 'TECHNICAL_ASSET';
+export type AssetImportPlanAction = 'CREATE' | 'MATCH' | 'REVIEW' | 'IGNORE';
+export type AssetImportPlanItemStatus = 'PLANNED' | 'MATCHED' | 'REVIEW' | 'IGNORED' | 'APPLIED' | 'ROLLED_BACK' | 'FAILED';
+
+export interface AssetImportPlanItem {
+  id: string;
+  planId: string;
+  itemOrder: number;
+  entityKey: string;
+  entityKind: AssetImportPlanEntityKind;
+  action: AssetImportPlanAction;
+  status: AssetImportPlanItemStatus;
+  assetTypeCode: string | null;
+  displayName: string;
+  generatedCode: string | null;
+  parentEntityKey: string | null;
+  matchedAssetId: string | null;
+  appliedAssetId: string | null;
+  appliedObjectId: string | null;
+  payload: Record<string, unknown>;
+  sourceRowNumbers: number[];
+  reviewCodes: string[];
+  resolutionNote: string | null;
+  resolvedBy: string | null;
+  resolvedAt: string | null;
+}
+
+export interface AssetImportPlan {
+  id: string;
+  batchId: string;
+  revision: number;
+  status: AssetImportPlanStatus;
+  externalIdNamespace: string | null;
+  operatorAssetId: string | null;
+  summary: Record<string, unknown>;
+  planHash: string;
+  generatedBy: string | null;
+  generatedAt: string;
+  appliedBy: string | null;
+  appliedAt: string | null;
+  applicationSummary: Record<string, unknown> | null;
+  rolledBackBy: string | null;
+  rolledBackAt: string | null;
+  rollbackSummary: Record<string, unknown> | null;
+  supersededAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+  masterStateStale: boolean;
+  masterStateHashAvailable: boolean;
+  masterStateCheckedAt: string;
+  previewItems: AssetImportPlanItem[];
+  reviewItems: AssetImportPlanItem[];
+}
+
+export interface AssetImportReviewItem extends AssetImportPlanItem {
+  batchId: string;
+  batchName: string;
+  sourceLabel: string | null;
+  profileCode: AssetImportProfileCode;
+  planRevision: number;
+  planStatus: AssetImportPlanStatus;
+  dependency: boolean;
+}
+
+export interface AssetImportOrganizationOption {
+  id: string;
+  code: string;
+  name: string;
+  legalName: string | null;
+}
+
+export type Position = [number, number];
+export type AssetGeometryType = 'POINT' | 'LINESTRING' | 'POLYGON';
+
+export type GeoJsonGeometry =
+  | { type: 'POINT'; coordinates: Position }
+  | { type: 'LINESTRING'; coordinates: Position[] }
+  | { type: 'POLYGON'; coordinates: Position[][] };
+
+export interface AssetGeometry {
+  assetId: string;
+  geometry: GeoJsonGeometry;
+  geometryType: AssetGeometryType;
+  source: 'WEB' | 'ANDROID' | 'IMPORT' | 'SURVEY';
+  accuracyM: number | null;
+  capturedAt: string | null;
+  deviceLabel: string | null;
+  createdAt: string;
+  updatedAt: string;
+  updatedBy: string | null;
+}
+
+export interface MapAssetProperties {
+  id: string;
+  code: string;
+  name: string;
+  commonName?: string | null;
+  typeId: string;
+  typeCode: string;
+  typeName: string;
+  parentId: string | null;
+  parentName: string | null;
+  informationStatus: AssetInformationStatus;
+  geometryType: AssetGeometryType;
+  accuracyM: number | null;
+  capturedAt: string | null;
+  updatedAt: string;
+}
+
+export interface MapAssetFeature {
+  type: 'Feature';
+  id: string;
+  geometry: GeoJsonGeometry;
+  properties: MapAssetProperties;
+}
+
+export interface MapAssetFeatureCollection {
+  type: 'FeatureCollection';
+  features: MapAssetFeature[];
+  meta: { count: number; truncated: boolean };
+}
+
+export type AssetMediaKind = 'PHOTO' | 'DOCUMENT';
+
+export interface AssetMedia {
+  id: string;
+  assetId: string;
+  kind: AssetMediaKind;
+  originalName: string;
+  mimeType: 'image/jpeg' | 'image/png' | 'image/webp' | 'application/pdf';
+  sizeBytes: number;
+  sha256: string;
+  title: string | null;
+  description: string | null;
+  capturedAt: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  accuracyM: number | null;
+  source: 'WEB' | 'ANDROID' | 'IMPORT';
+  uploadedBy: string | null;
+  uploadedByUsername: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export type AssetVersionChangeType =
+  | 'BASELINE'
+  | 'CREATED'
+  | 'UPDATED'
+  | 'CONTEXT_CHANGED'
+  | 'STATUS_CHANGED'
+  | 'OPERATIONAL_STATUS_CHANGED'
+  | 'REGISTRY_UPDATED'
+  | 'GEOMETRY_UPDATED'
+  | 'GEOMETRY_REMOVED'
+  | 'MEDIA_UPLOADED'
+  | 'MEDIA_UPDATED'
+  | 'MEDIA_REMOVED'
+  | 'PROVENANCE_BASELINE'
+  | 'PROVENANCE_UPDATED'
+  | 'PROVENANCE_VERIFIED';
+
+export interface AssetVersionSnapshot {
+  id: string;
+  code: string;
+  name: string;
+  description: string | null;
+  type: { id: string; code: string; name: string; operationalRole?: AssetTypeOperationalRole };
+  parent: { id: string; code: string; name: string } | null;
+  operationalArea?: { id: string; code: string; name: string } | null;
+  operatorCompany?: { id: string; code: string; name: string } | null;
+  informationStatus: AssetInformationStatus;
+  operationalStatus: AssetOperationalStatus;
+  organizationProfile?: Record<string, unknown> | null;
+  organizationMemberships?: Array<Record<string, unknown>>;
+  externalIdentifiers?: Array<Record<string, unknown>>;
+  sourceDocuments?: Array<Record<string, unknown>>;
+  legalRights?: Array<Record<string, unknown>>;
+  attributes: Array<{
+    definitionId: string;
+    code: string;
+    name: string;
+    dataType: AssetAttributeDataType;
+    isRequired: boolean;
+    unit: string | null;
+    options: string[] | null;
+    sortOrder: number;
+    value: unknown;
+  }>;
+  geometry: AssetGeometry | null;
+  media?: AssetMedia[];
+  provenance?: {
+    origin: AssetDataOrigin;
+    sourceName: string | null;
+    sourceReference: string | null;
+    observedAt: string | null;
+    notes: string | null;
+    verifiedAt: string | null;
+    verifiedBy: string | null;
+    updatedAt: string;
+    updatedBy: string | null;
+  };
+  createdAt: string;
+  updatedAt: string;
+  createdBy: string | null;
+  updatedBy: string | null;
+  currentVersion: number;
+}
+
+export interface AssetVersionSummary {
+  id: string;
+  assetId: string;
+  assetCode: string;
+  assetName: string;
+  typeId: string;
+  typeName: string;
+  informationStatus: AssetInformationStatus;
+  operationalStatus: AssetOperationalStatus;
+  versionNumber: number;
+  changeType: AssetVersionChangeType;
+  changedFields: string[];
+  occurredAt: string;
+  actorUserId: string | null;
+  actorUsername: string | null;
+  source: 'WEB' | 'ANDROID' | 'SYSTEM' | 'IMPORT';
+  requestId: string | null;
+  isCurrent: boolean;
+}
+
+export interface AssetVersionDetail extends AssetVersionSummary {
+  snapshot: AssetVersionSnapshot;
+}
+
+export interface TemporalAssetSummary extends AssetVersionSummary {
+  effectiveUntil: string | null;
+}
+
+export interface TemporalAssetDetail extends TemporalAssetSummary {
+  snapshot: AssetVersionSnapshot;
+  asOf: string;
+}
+
+export type SurveyCampaignStatus =
+  | 'DRAFT' | 'PLANNED' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED';
+
+export type SurveyTargetStatus =
+  | 'PENDING' | 'IN_PROGRESS' | 'SUBMITTED' | 'COMPLETED' | 'SKIPPED';
+
+export interface SurveyPerson {
+  id: string;
+  username: string;
+  firstName: string;
+  lastName: string;
+}
+
+export interface SurveyCampaignListItem {
+  id: string;
+  code: string;
+  name: string;
+  description: string | null;
+  status: SurveyCampaignStatus;
+  plannedStartAt: string | null;
+  plannedEndAt: string | null;
+  scopeAsset: { id: string; code: string; name: string } | null;
+  coordinator: SurveyPerson | null;
+  targetCount: number;
+  pendingCount: number;
+  inProgressCount: number;
+  submittedCount: number;
+  completedCount: number;
+  skippedCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SurveyTarget {
+  id: string;
+  campaignId: string;
+  asset: { id: string; code: string; name: string; typeName: string };
+  assignedUser: SurveyPerson | null;
+  status: SurveyTargetStatus;
+  dueAt: string | null;
+  instructions: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SurveyCampaign extends SurveyCampaignListItem {
+  targets: SurveyTarget[];
+}
+
+export type SurveyReportOutcome = 'CONFIRMED' | 'CHANGES_RECORDED' | 'NOT_LOCATED';
+export type SurveyReportStatus = 'DRAFT' | 'SUBMITTED' | 'APPROVED' | 'REJECTED';
+export type SurveyReportVersionEvent = 'SUBMITTED' | 'APPROVED' | 'REJECTED';
+
+export interface SurveyTargetReport {
+  id: string;
+  targetId: string;
+  outcome: SurveyReportOutcome | null;
+  status: SurveyReportStatus;
+  observedAt: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  accuracyM: number | null;
+  notes: string | null;
+  assetVersionAtSubmission: number | null;
+  submittedAt: string | null;
+  submittedBy: SurveyPerson | null;
+  reviewedAt: string | null;
+  reviewedBy: SurveyPerson | null;
+  reviewNotes: string | null;
+  selectedMediaIds: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SurveyReportMedia extends AssetMedia {
+  kind: 'PHOTO';
+  selected: boolean;
+}
+
+export interface SurveyReportVersion {
+  id: string;
+  versionNumber: number;
+  event: SurveyReportVersionEvent;
+  snapshot: Record<string, unknown>;
+  actorUserId: string | null;
+  actorUsername: string | null;
+  createdAt: string;
+}
+
+export interface SurveyExecution {
+  target: {
+    id: string;
+    status: SurveyTargetStatus;
+    dueAt: string | null;
+    instructions: string | null;
+    assignedUser: SurveyPerson | null;
+  };
+  campaign: {
+    id: string;
+    code: string;
+    name: string;
+    status: SurveyCampaignStatus;
+  };
+  asset: {
+    id: string;
+    code: string;
+    name: string;
+    typeName: string;
+    informationStatus: AssetInformationStatus;
+    currentVersion: number;
+  };
+  report: SurveyTargetReport | null;
+  availableMedia: SurveyReportMedia[];
+  versions: SurveyReportVersion[];
+}
+
+export type InspectionVisitStatus =
+  | 'DRAFT' | 'PLANNED' | 'IN_PROGRESS' | 'CLOSED' | 'CANCELLED';
+
+export interface InspectionPerson {
+  id: string;
+  username: string;
+  firstName: string;
+  lastName: string;
+}
+
+export interface InspectionAssetSummary {
+  id: string;
+  code: string;
+  name: string;
+  commonName?: string | null;
+  typeName: string;
+  operatorCompany?: { id: string; code: string; name: string } | null;
+  operationalArea?: { id: string; code: string; name: string } | null;
+}
+
+export interface InspectionPlanningContextAsset {
+  id: string;
+  code: string;
+  name: string;
+}
+
+export type InspectionVisitAssetPlanningSource = 'LEGACY' | 'AUTOMATIC' | 'PREVENTIVE' | 'VERIFICATION';
+export type InspectionChecklistItemKind = 'ANTECEDENT' | 'COMPANY_OVERDUE' | 'VERIFICATION_OVERDUE' | 'UPCOMING_CONTROL';
+
+export interface InspectionPlannedAsset extends InspectionAssetSummary {
+  included: boolean;
+  planningSource: InspectionVisitAssetPlanningSource;
+  exclusionReason: string | null;
+  excludedAt: string | null;
+  excludedBy: InspectionPerson | null;
+}
+
+export interface InspectionVisitChecklistItem {
+  id: string;
+  findingId: string;
+  findingCode: string;
+  findingTitle: string;
+  findingStatus: InspectionFindingStatus;
+  severity: number | null;
+  itemKind: InspectionChecklistItemKind;
+  referenceOn: string | null;
+  asset: InspectionAssetSummary;
+  assetIncluded: boolean;
+}
+
+export interface InspectionVisitChecklistSummary {
+  generation: number;
+  generatedAt: string | null;
+  stale: boolean;
+  antecedents: number;
+  companyOverdue: number;
+  verificationOverdue: number;
+  upcomingControls: number;
+  actionableAssets: number;
+  excludedAssets: number;
+  items: InspectionVisitChecklistItem[];
+}
+
+export interface InspectionVisitListItem {
+  id: string;
+  code: string;
+  title: string;
+  objective: string | null;
+  status: InspectionVisitStatus;
+  scopeAsset: InspectionAssetSummary | null;
+  operationalArea: InspectionPlanningContextAsset | null;
+  operatorCompany: InspectionPlanningContextAsset | null;
+  leadInspector: InspectionPerson | null;
+  plannedStartAt: string | null;
+  plannedEndAt: string | null;
+  actualStartedAt: string | null;
+  actualClosedAt: string | null;
+  instructions: string | null;
+  cancellationReason: string | null;
+  checklistGeneration: number;
+  checklistGeneratedAt: string | null;
+  assetCount: number;
+  memberCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export type InspectionVerificationOutcome = 'RESOLVED' | 'NOT_RESOLVED' | 'REQUIRES_NEW_DATE';
+
+export interface InspectionVerificationFindingSummary {
+  id: string;
+  code: string;
+  title: string;
+  status: InspectionFindingStatus;
+  nextControlOn: string | null;
+  assetId: string;
+  assetCode: string;
+  assetName: string;
+  targetControlOn: string | null;
+  outcome: InspectionVerificationOutcome | null;
+  resultNotes: string | null;
+  verifiedAt: string | null;
+  resultRecordedAt: string | null;
+  rescheduledControlOn: string | null;
+  verificationEvidenceCount: number;
+}
+
+export interface InspectionVisit extends InspectionVisitListItem {
+  assets: InspectionAssetSummary[];
+  planningAssets: InspectionPlannedAsset[];
+  team: InspectionPerson[];
+  verificationFindings: InspectionVerificationFindingSummary[];
+  checklist: InspectionVisitChecklistSummary;
+}
+
+export type InspectionActStatus =
+  | 'DRAFT' | 'READY' | 'CLOSED' | 'CANCELLED' | 'RECTIFIED';
+
+export type InspectionActVersionEvent =
+  | 'CREATED' | 'UPDATED' | 'READY' | 'REOPENED' | 'CLOSED' | 'CANCELLED';
+
+export interface InspectionActListItem {
+  id: string;
+  visitId: string;
+  visit: {
+    id: string;
+    code: string;
+    title: string;
+    status: InspectionVisitStatus;
+    actualStartedAt: string | null;
+  };
+  actYear: number;
+  actNumber: number;
+  code: string;
+  status: InspectionActStatus;
+  occurredAt: string;
+  title: string;
+  summary: string;
+  observations: string | null;
+  currentVersion: number;
+  cancellationReason: string | null;
+  closedAt: string | null;
+  closedBy: string | null;
+  closureSha256: string | null;
+  assetCount: number;
+  findingCount: number;
+  companies: Array<{ id: string; code: string; name: string }>;
+  areas: Array<{ id: string; code: string; name: string }>;
+  report: null | {
+    id: string;
+    code: string;
+    status: InspectionReportStatus;
+    pdfStatus: InspectionReportPdfStatus;
+    generatedAt: string;
+  };
+  createdBy: InspectionPerson | null;
+  updatedBy: InspectionPerson | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface InspectionActVersion {
+  id: string;
+  versionNumber: number;
+  event: InspectionActVersionEvent;
+  snapshot: Record<string, unknown>;
+  actorUserId: string | null;
+  actorUsername: string | null;
+  createdAt: string;
+}
+
+export interface InspectionAct extends InspectionActListItem {
+  assets: InspectionAssetSummary[];
+  versions: InspectionActVersion[];
+}
+
+export type InspectionReportStatus = 'FROZEN' | 'CANCELLED';
+export type InspectionReportPdfStatus = 'PENDING' | 'READY' | 'FAILED';
+export type InspectionReportWordStatus = 'PENDING' | 'READY' | 'FAILED';
+export type InspectionReportReviewStatus = 'PENDING_REVIEW' | 'APPROVED' | 'SIGNED';
+
+export interface InspectionReportListItem {
+  id: string;
+  visitId: string;
+  actId: string;
+  reportYear: number;
+  reportNumber: number;
+  code: string;
+  status: InspectionReportStatus;
+  pdfStatus: InspectionReportPdfStatus;
+  wordStatus: InspectionReportWordStatus;
+  wordGeneratedAt: string | null;
+  reviewStatus: InspectionReportReviewStatus;
+  currentRevisionNumber: number;
+  approvedAt: string | null;
+  signedAt: string | null;
+  title: string;
+  actVersion: number;
+  actClosureSha256: string;
+  frozenSha256: string;
+  generatedAt: string;
+  generatedBy: InspectionPerson;
+  act: {
+    id: string;
+    code: string;
+    title: string;
+    status: InspectionActStatus;
+    occurredAt: string;
+    closedAt: string | null;
+  };
+  visit: {
+    id: string;
+    code: string;
+    title: string;
+    status: InspectionVisitStatus;
+  };
+  companies: Array<{ id: string; code: string; name: string }>;
+  areas: Array<{ id: string; code: string; name: string }>;
+  findingCount: number;
+}
+
+export interface InspectionReport extends InspectionReportListItem {
+  frozenSnapshot: Record<string, unknown>;
+}
+
+export type InspectionReportRevisionSource = 'AUTO' | 'DIRECTOR_UPLOAD';
+
+export interface InspectionReportRevision {
+  id: string;
+  reportId: string;
+  revisionNumber: number;
+  source: InspectionReportRevisionSource;
+  originalName: string;
+  mimeType: string;
+  sizeBytes: number;
+  sha256: string;
+  changeSummary: string | null;
+  createdAt: string;
+  createdBy: InspectionPerson;
+}
+
+export interface InspectionReportSignature {
+  id: string;
+  revisionId: string;
+  signedAt: string;
+  confirmationText: string;
+  signatureSha256: string;
+  signedBy: InspectionPerson;
+}
+
+export interface InspectionReportReview {
+  reportId: string;
+  reportCode: string;
+  reviewStatus: InspectionReportReviewStatus;
+  currentRevisionNumber: number;
+  approvedRevisionId: string | null;
+  approvedAt: string | null;
+  reviewNote: string | null;
+  approvedBy: InspectionPerson | null;
+  signature: InspectionReportSignature | null;
+  revisions: InspectionReportRevision[];
+}
+
+export interface PendingInspectionReportItem {
+  actId: string;
+  visitId: string;
+  actCode: string;
+  actTitle: string;
+  actYear: number;
+  occurredAt: string;
+  closedAt: string;
+  closureSha256: string;
+  visitCode: string;
+  visitTitle: string;
+  companies: Array<{ id: string; code: string; name: string }>;
+  areas: Array<{ id: string; code: string; name: string }>;
+  findingCount: number;
+}
+
+export type InspectionResponsibleAttendanceStatus = 'PRESENT' | 'ABSENT';
+export type InspectionResponsibleDocumentType = 'DNI' | 'CUIL' | 'PASSPORT' | 'OTHER';
+export type InspectionActSignatureStatus = 'SIGNED' | 'REFUSED' | 'ABSENT';
+export type InspectionActSignerType = 'INSPECTOR' | 'COMPANY_RESPONSIBLE';
+export type InspectionActUploadMode = 'IMMEDIATE' | 'DEFERRED';
+
+export interface InspectionActResponsible {
+  actId: string;
+  attendanceStatus: InspectionResponsibleAttendanceStatus;
+  fullName: string | null;
+  documentType: InspectionResponsibleDocumentType | null;
+  documentNumber: string | null;
+  position: string | null;
+  email: string | null;
+  phone: string | null;
+  absenceReason: string | null;
+  updatedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface InspectionActSignature {
+  id: string;
+  actId: string;
+  signerType: InspectionActSignerType;
+  signerUserId: string | null;
+  signerName: string;
+  documentType: InspectionResponsibleDocumentType | null;
+  documentNumber: string | null;
+  position: string | null;
+  status: InspectionActSignatureStatus;
+  reason: string | null;
+  companyManifestation: 'CONFORMITY' | 'DISSENT' | null;
+  companyStatement: string | null;
+  mimeType: string | null;
+  sizeBytes: number | null;
+  imageSha256: string | null;
+  consentText: string | null;
+  consentVersion: string | null;
+  consentAcceptedAt: string | null;
+  clientSignedAt: string | null;
+  signedAt: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  accuracyM: number | null;
+  deviceLabel: string | null;
+  source: 'WEB' | 'ANDROID';
+  preparedSha256: string;
+  signaturePayloadSha256: string;
+  uploadedBy: string;
+  uploadedByUsername: string;
+  createdAt: string;
+}
+
+export interface InspectionClosure {
+  act: {
+    id: string;
+    code: string;
+    status: InspectionActStatus;
+    visitId: string;
+    currentVersion: number;
+    closedAt: string | null;
+    closedBy: string | null;
+    closureSha256: string | null;
+  };
+  visit: {
+    id: string;
+    code: string;
+    status: InspectionVisitStatus;
+    actualClosedAt: string | null;
+  };
+  responsible: InspectionActResponsible | null;
+  closure: null | {
+    schemaVersion: string;
+    preparedSha256: string;
+    preparedAt: string;
+    preparedBy: string;
+    finalSha256: string | null;
+    deviceClosedAt: string | null;
+    serverClosedAt: string | null;
+    uploadMode: InspectionActUploadMode | null;
+    closedBy: string | null;
+    isCurrent: boolean;
+  };
+  signatures: InspectionActSignature[];
+  consents: {
+    version: string;
+    inspector: string;
+    company: string;
+  };
+}
+
+export interface FindingCategory {
+  id: string;
+  code: string;
+  name: string;
+  sortOrder: number;
+}
+
+export interface FindingCatalogItem {
+  id: string;
+  categoryId: string;
+  categoryName: string;
+  code: string;
+  sourceNumber: number;
+  title: string;
+  legalBasis: string | null;
+  glossary: string | null;
+  suggestedSeverity: number | null;
+  revision: number;
+}
+
+export interface FindingCatalog {
+  categories: FindingCategory[];
+  items: FindingCatalogItem[];
+}
+
+export interface FindingAdminCategory extends FindingCategory {
+  isActive: boolean;
+  itemCount: number;
+  activeItemCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface FindingAdminCatalogItem extends FindingCatalogItem {
+  categoryCode: string;
+  categoryActive: boolean;
+  importNote: string | null;
+  isActive: boolean;
+  usageCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface FindingAdminCatalog {
+  categories: FindingAdminCategory[];
+  items: FindingAdminCatalogItem[];
+}
+
+export interface FindingCatalogSelectionItem {
+  id: string;
+  categoryId: string;
+  categoryName: string;
+  code: string;
+  sourceNumber: number;
+  title: string;
+  suggestedSeverity: number | null;
+  enabled: boolean;
+}
+
+export interface FindingCatalogAssetTypeSelection {
+  assetType: { id: string; code: string; name: string; operationalRole: AssetTypeOperationalRole };
+  configured: boolean;
+  reason: string | null;
+  items: FindingCatalogSelectionItem[];
+}
+
+export interface FindingCatalogAssetSelection {
+  asset: {
+    id: string;
+    code: string;
+    name: string;
+    assetTypeId: string;
+    assetTypeCode: string;
+    assetTypeName: string;
+  };
+  typeConfigured: boolean;
+  typeReason: string | null;
+  items: Array<FindingCatalogSelectionItem & {
+    typeDefaultEnabled: boolean;
+    assetOverride: boolean | null;
+  }>;
+}
+
+export interface FindingCatalogApplicable extends FindingCatalog {
+  asset: FindingCatalogAssetSelection['asset'];
+  typeConfigured: boolean;
+  configurationReason: string | null;
+  other: { enabled: true; code: 'OTHER'; label: string; help: string };
+}
+
+export type FindingCatalogProposalStatus = 'PENDING' | 'MATCHED' | 'REJECTED';
+export interface FindingCatalogProposal {
+  id: string;
+  findingId: string;
+  findingCode: string;
+  assetId: string;
+  assetCode: string;
+  assetName: string;
+  assetTypeId: string;
+  assetTypeCode: string;
+  assetTypeName: string;
+  proposedTitle: string;
+  proposedLegalBasis: string | null;
+  proposedSeverity: number | null;
+  description: string;
+  status: FindingCatalogProposalStatus;
+  resolvedCatalogItemId: string | null;
+  resolvedCatalogCode: string | null;
+  resolvedCatalogTitle: string | null;
+  officeNotes: string | null;
+  reviewedBy: string | null;
+  reviewedByUsername: string | null;
+  reviewedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export type InspectionFindingWorkflow =
+  | 'ALL'
+  | 'OPEN'
+  | 'WAITING_COMPANY'
+  | 'COMPANY_OVERDUE'
+  | 'TO_SCHEDULE_VERIFICATION'
+  | 'TO_VERIFY'
+  | 'VERIFICATION_OVERDUE'
+  | 'READY_TO_CLOSE'
+  | 'CLOSED';
+
+export interface InspectionFindingWorkflowCounters {
+  open: number;
+  waitingCompany: number;
+  companyOverdue: number;
+  companyDueNext7Days: number;
+  awaitingVerificationSchedule: number;
+  toVerify: number;
+  verificationOverdue: number;
+  verificationNext30Days: number;
+  readyToClose: number;
+  closed: number;
+}
+
+export interface InspectionFindingGlobalPage extends Page<InspectionFinding> {
+  counters: InspectionFindingWorkflowCounters;
+}
+
+export type VerificationPlanningStatus = 'ALL' | 'UNPLANNED' | 'PLANNED';
+
+export interface VerificationPlanningItem {
+  id: string;
+  code: string;
+  title: string;
+  status: 'OPEN';
+  nextControlOn: string;
+  companyResponseReceivedOn: string;
+  asset: { id: string; code: string; name: string; typeName: string };
+  company: { id: string; code: string; name: string } | null;
+  area: { id: string; code: string; name: string } | null;
+  act: { id: string; code: string };
+  sourceVisit: { id: string; code: string; title: string };
+  verificationVisit: null | {
+    id: string;
+    code: string;
+    title: string;
+    status: InspectionVisitStatus;
+    plannedStartAt: string | null;
+    plannedEndAt: string | null;
+  };
+}
+
+export interface VerificationPlanningCounters {
+  eligible: number;
+  unplanned: number;
+  overdueUnplanned: number;
+  dueNext30Days: number;
+  planned: number;
+}
+
+export interface VerificationPlanningPage extends Page<VerificationPlanningItem> {
+  counters: VerificationPlanningCounters;
+}
+
+export interface PlannedVerificationVisitResult {
+  visit: {
+    id: string;
+    code: string;
+    title: string;
+    status: InspectionVisitStatus;
+    plannedStartAt: string | null;
+    plannedEndAt: string | null;
+  };
+  company: { id: string; code: string; name: string };
+  area: { id: string; code: string; name: string };
+  findingCount: number;
+  assetCount: number;
+}
+
+export type InspectionFindingStatus = 'OPEN' | 'CLOSED' | 'VOIDED';
+export type InspectionFindingVerificationEventType =
+  | 'CONTROL_DATE_DEFINED'
+  | 'CONTROL_DATE_CHANGED'
+  | 'CONTROL_DATE_CLEARED'
+  | 'VISIT_PLANNED'
+  | 'RESULT_RECORDED';
+
+export interface InspectionFindingVerificationEvent {
+  id: string;
+  eventType: InspectionFindingVerificationEventType;
+  occurredAt: string;
+  targetControlOn: string | null;
+  previousControlOn: string | null;
+  nextControlOn: string | null;
+  outcome: InspectionVerificationOutcome | null;
+  notes: string | null;
+  actorUserId: string | null;
+  actorUsername: string | null;
+  verificationVisit: null | {
+    id: string;
+    code: string;
+    title: string;
+    status: InspectionVisitStatus;
+    plannedStartAt: string | null;
+  };
+  evidenceCount: number;
+}
+export type InspectionFindingVersionEvent = 'CREATED' | 'UPDATED' | 'FOLLOW_UP_UPDATED' | 'VERIFICATION_RECORDED';
+export type InspectionFindingOfficeStage =
+  | 'WAITING_COMPANY'
+  | 'COMPANY_OVERDUE'
+  | 'DEFINE_VERIFICATION'
+  | 'PLAN_VERIFICATION'
+  | 'VERIFICATION_PLANNED'
+  | 'RESCHEDULE_VERIFICATION'
+  | 'READY_TO_CLOSE'
+  | 'CLOSED';
+
+export interface InspectionFindingOfficeWorkflow {
+  stage: InspectionFindingOfficeStage;
+  label: string;
+  action: string;
+  dueOn: string | null;
+  overdue: boolean;
+}
+
+export interface InspectionFinding {
+  id: string;
+  actId: string;
+  assetId: string;
+  catalogItemId: string | null;
+  findingNumber: number;
+  code: string;
+  status: InspectionFindingStatus;
+  title: string;
+  description: string;
+  legalBasis: string | null;
+  glossary: string | null;
+  catalogRevision: number | null;
+  suggestedSeverity: number | null;
+  severity: number | null;
+  correctionDueOn: string | null;
+  responseDueBasis: 'FINDING_DATE' | 'REPORT_NOTIFICATION' | null;
+  responseDueDays: number | null;
+  responseDueBaseOn: string | null;
+  reportNotifiedOn: string | null;
+  companyResponse: string | null;
+  companyResponseReceivedOn: string | null;
+  companyCommittedCorrectionOn: string | null;
+  nextControlOn: string | null;
+  currentVersion: number;
+  closedAt: string | null;
+  closureNotes: string | null;
+  asset: InspectionAssetSummary;
+  catalog: {
+    id: string;
+    code: string;
+    categoryId: string;
+    categoryName: string;
+    sourceNumber: number;
+    revision: number;
+    suggestedSeverity: number | null;
+  } | null;
+  document: {
+    actId: string;
+    actCode: string;
+    actStatus: InspectionActStatus;
+    visitId: string;
+    visitCode: string;
+    visitTitle: string;
+    visitStatus: InspectionVisitStatus;
+  };
+  verificationVisit: null | {
+    id: string;
+    code: string;
+    title: string;
+    status: InspectionVisitStatus;
+    plannedStartAt: string | null;
+  };
+  latestVerification: null | {
+    visitId: string;
+    visitCode: string;
+    visitStatus: InspectionVisitStatus;
+    targetControlOn: string | null;
+    outcome: InspectionVerificationOutcome | null;
+    resultNotes: string | null;
+    verifiedAt: string | null;
+    resultRecordedAt: string | null;
+    rescheduledControlOn: string | null;
+    evidenceCount: number;
+  };
+  verificationHistory?: InspectionFindingVerificationEvent[];
+  createdAt: string;
+  updatedAt: string;
+  officeWorkflow?: InspectionFindingOfficeWorkflow;
+  versions?: Array<{
+    id: string;
+    versionNumber: number;
+    event: InspectionFindingVersionEvent;
+    snapshot: Record<string, unknown>;
+    actorUserId: string | null;
+    actorUsername: string | null;
+    createdAt: string;
+  }>;
+}
+
+export type InspectionEvidenceKind = 'PHOTO' | 'DOCUMENT';
+export type InspectionEvidencePurpose =
+  | 'OBSERVATION'
+  | 'VERIFICATION'
+  | 'COMPANY_RESPONSE'
+  | 'COMMUNICATION_ATTACHMENT'
+  | 'OTHER_DOCUMENT';
+
+export interface InspectionFindingCommunication {
+  id: string;
+  findingId: string;
+  direction: 'INBOUND' | 'OUTBOUND' | 'INTERNAL';
+  channel: 'EMAIL' | 'IN_PERSON' | 'PHONE' | 'LETTER' | 'SYSTEM' | 'OTHER';
+  type: 'COMPANY_RESPONSE' | 'AUTHORITY_NOTICE' | 'FOLLOW_UP' | 'OTHER';
+  occurredAt: string;
+  subject: string;
+  details: string | null;
+  contactName: string | null;
+  contactEmail: string | null;
+  createdBy: string | null;
+  createdByUsername: string | null;
+  attachmentCount: number;
+  createdAt: string;
+}
+
+export interface InspectionFindingEvidence {
+  id: string;
+  findingId: string;
+  communicationId: string | null;
+  verificationVisitId: string | null;
+  communication: {
+    id: string;
+    type: InspectionFindingCommunication['type'];
+    direction: InspectionFindingCommunication['direction'];
+    subject: string;
+  } | null;
+  kind: InspectionEvidenceKind;
+  purpose: InspectionEvidencePurpose;
+  originalName: string;
+  mimeType: string;
+  sizeBytes: number;
+  sha256: string;
+  title: string | null;
+  description: string | null;
+  capturedAt: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  accuracyM: number | null;
+  deviceLabel: string | null;
+  source: 'WEB' | 'ANDROID' | 'IMPORT';
+  uploadedBy: string | null;
+  uploadedByUsername: string | null;
+  createdAt: string;
+}
+
+let csrfToken: string | null = null;
+let refreshPromise: Promise<void> | null = null;
+
+function readCsrfCookie(): string | null {
+  if (typeof document === 'undefined') return null;
+  const cookies = document.cookie.split(';').map((item) => item.trim());
+  const exact = cookies.find((item) => item.startsWith('dhv2_csrf='));
+  const fallback = cookies.find((item) => item.split('=', 1)[0]?.endsWith('_csrf'));
+  const raw = exact ?? fallback;
+  if (!raw) return null;
+  const separator = raw.indexOf('=');
+  return separator >= 0 ? decodeURIComponent(raw.slice(separator + 1)) : null;
+}
+
+function isUnsafe(method: string): boolean {
+  return !['GET', 'HEAD', 'OPTIONS'].includes(method.toUpperCase());
+}
+
+async function decodeResponse<T>(response: Response): Promise<T> {
+  const body = await response.json().catch(() => null) as {
+    code?: string;
+    message?: string;
+    requestId?: string;
+  } | null;
+  if (!response.ok) {
+    throw new ApiError(
+      response.status,
+      body?.code ?? 'REQUEST_ERROR',
+      body?.message ?? `La solicitud falló con HTTP ${response.status}`,
+      body?.requestId,
+    );
+  }
+  return body as T;
+}
+
+async function rawRequest<T>(path: string, init: RequestInit = {}): Promise<T> {
+  const method = (init.method ?? 'GET').toUpperCase();
+  const headers = new Headers(init.headers);
+  headers.set('Accept', 'application/json');
+  if (init.body && !(init.body instanceof FormData)) {
+    headers.set('Content-Type', 'application/json');
+  }
+  if (isUnsafe(method) && path !== '/auth/login') {
+    const token = csrfToken ?? readCsrfCookie();
+    if (token) headers.set('x-csrf-token', token);
+  }
+
+  const response = await fetch(`${API_BASE}${path}`, {
+    ...init,
+    method,
+    headers,
+    credentials: 'include',
+    cache: 'no-store',
+  });
+  return decodeResponse<T>(response);
+}
+
+async function refreshAccess(): Promise<void> {
+  if (!refreshPromise) {
+    refreshPromise = rawRequest<AuthResponse>('/auth/refresh', { method: 'POST' })
+      .then((response) => { csrfToken = response.csrfToken; })
+      .finally(() => { refreshPromise = null; });
+  }
+  return refreshPromise;
+}
+
+export async function apiRequest<T>(
+  path: string,
+  init: RequestInit = {},
+  retrySession = true,
+): Promise<T> {
+  try {
+    return await rawRequest<T>(path, init);
+  } catch (error) {
+    if (
+      retrySession && error instanceof ApiError && error.status === 401 &&
+      path !== '/auth/login' && path !== '/auth/refresh'
+    ) {
+      try {
+        await refreshAccess();
+        return await rawRequest<T>(path, init);
+      } catch (refreshError) {
+        csrfToken = null;
+        window.dispatchEvent(new Event('dhv2:unauthorized'));
+        throw refreshError;
+      }
+    }
+    throw error;
+  }
+}
+
+async function rawBlobRequest(path: string): Promise<Blob> {
+  const response = await fetch(`${API_BASE}${path}`, {
+    method: 'GET',
+    headers: { Accept: '*/*' },
+    credentials: 'include',
+    cache: 'no-store',
+  });
+  if (!response.ok) return decodeResponse<never>(response);
+  return response.blob();
+}
+
+async function apiBlobRequest(path: string): Promise<Blob> {
+  try {
+    return await rawBlobRequest(path);
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 401) {
+      try {
+        await refreshAccess();
+        return await rawBlobRequest(path);
+      } catch (refreshError) {
+        csrfToken = null;
+        window.dispatchEvent(new Event('dhv2:unauthorized'));
+        throw refreshError;
+      }
+    }
+    throw error;
+  }
+}
+
+export function getHealth() { return apiRequest<HealthResponse>('/health', {}, false); }
+
+export async function login(identifier: string, password: string) {
+  const response = await apiRequest<AuthResponse>('/auth/login', {
+    method: 'POST',
+    body: JSON.stringify({ identifier, password, deviceLabel: 'Panel web' }),
+  }, false);
+  csrfToken = response.csrfToken;
+  return response;
+}
+
+export async function getMe() {
+  const response = await apiRequest<{ user: AuthUser }>('/auth/me');
+  return response.user;
+}
+
+export async function logout() {
+  await apiRequest<{ status: string }>('/auth/logout', { method: 'POST' });
+  csrfToken = null;
+}
+
+export function changePassword(currentPassword: string, newPassword: string) {
+  return apiRequest<{ status: string; mustChangePassword: false }>('/auth/change-password', {
+    method: 'POST', body: JSON.stringify({ currentPassword, newPassword }),
+  });
+}
+
+export function getDashboardSummary() { return apiRequest<DashboardSummary>('/dashboard/summary'); }
+
+export function listUsers(params: {
+  page?: number; pageSize?: number; search?: string; status?: 'ACTIVE' | 'INACTIVE' | '';
+} = {}) {
+  const query = new URLSearchParams();
+  query.set('page', String(params.page ?? 1));
+  query.set('pageSize', String(params.pageSize ?? 20));
+  if (params.search) query.set('search', params.search);
+  if (params.status) query.set('status', params.status);
+  return apiRequest<Page<AdministrativeUser>>(`/users?${query}`);
+}
+
+export function getUser(id: string) { return apiRequest<AdministrativeUser>(`/users/${id}`); }
+
+export function createUser(input: {
+  username: string; email?: string; firstName: string; lastName: string;
+  password: string; mustChangePassword: boolean; roleIds: string[];
+}) {
+  return apiRequest<AdministrativeUser>('/users', {
+    method: 'POST', body: JSON.stringify(input),
+  });
+}
+
+export function updateUser(id: string, input: {
+  username?: string; email?: string | null; firstName?: string; lastName?: string;
+}) {
+  return apiRequest<AdministrativeUser>(`/users/${id}`, {
+    method: 'PATCH', body: JSON.stringify(input),
+  });
+}
+
+export function resetUserPassword(id: string, password: string, mustChangePassword = true) {
+  return apiRequest<AdministrativeUser>(`/users/${id}/reset-password`, {
+    method: 'POST',
+    body: JSON.stringify({ password, mustChangePassword }),
+  });
+}
+
+export function updateUserStatus(id: string, status: 'ACTIVE' | 'INACTIVE') {
+  return apiRequest<AdministrativeUser>(`/users/${id}/status`, {
+    method: 'PATCH', body: JSON.stringify({ status }),
+  });
+}
+
+export function replaceUserRoles(id: string, roleIds: string[]) {
+  return apiRequest<AdministrativeUser>(`/users/${id}/roles`, {
+    method: 'PUT', body: JSON.stringify({ roleIds }),
+  });
+}
+
+export async function listRoles() {
+  return (await apiRequest<{ data: AdministrativeRole[] }>('/roles')).data;
+}
+
+export async function listPermissions() {
+  return (await apiRequest<{ data: Permission[] }>('/roles/permissions')).data;
+}
+
+export function createRole(input: {
+  code: string; name: string; description: string; permissionIds: string[];
+}) {
+  return apiRequest<AdministrativeRole>('/roles', {
+    method: 'POST', body: JSON.stringify(input),
+  });
+}
+
+export function updateRole(id: string, input: { name: string; description: string }) {
+  return apiRequest<AdministrativeRole>(`/roles/${id}`, {
+    method: 'PATCH', body: JSON.stringify(input),
+  });
+}
+
+export function replaceRolePermissions(id: string, permissionIds: string[]) {
+  return apiRequest<AdministrativeRole>(`/roles/${id}/permissions`, {
+    method: 'PUT', body: JSON.stringify({ permissionIds }),
+  });
+}
+
+export function listAudit(params: Record<string, string | number | undefined>) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== '') query.set(key, String(value));
+  });
+  return apiRequest<Page<AuditEventSummary>>(`/audit?${query}`);
+}
+
+export function getAuditEvent(id: string) {
+  return apiRequest<AuditEventDetail>(`/audit/${id}`);
+}
+
+export async function listAssetTypes() {
+  return (await apiRequest<{ data: AssetType[] }>('/asset-types')).data;
+}
+
+export function getMasterBootstrapStatus() {
+  return apiRequest<MasterBootstrapStatus>('/asset-types/bootstrap-status');
+}
+
+export function bootstrapMasterDefaults() {
+  return apiRequest<MasterBootstrapResult>('/asset-types/bootstrap-defaults', {
+    method: 'POST',
+  });
+}
+
+export function getMasterEnrichmentStatus() {
+  return apiRequest<MasterEnrichmentStatus>('/asset-types/enrichment-status');
+}
+
+export function enrichMasterDefaults() {
+  return apiRequest<MasterBootstrapResult>('/asset-types/enrich-defaults', {
+    method: 'POST',
+  });
+}
+
+export async function listOperationalAreas(parentId?: string) {
+  const query = parentId ? `?${new URLSearchParams({ parentId })}` : '';
+  return (await apiRequest<{ data: OperationalAssetSummary[] }>(`/asset-operational-relations/areas${query}`)).data;
+}
+
+export async function listOperationalCompanies() {
+  return (await apiRequest<{ data: OperationalAssetSummary[] }>('/asset-operational-relations/companies')).data;
+}
+
+export async function listCompaniesForArea(areaId: string) {
+  return (await apiRequest<{ data: OperationalAssetSummary[] }>(`/asset-operational-relations/areas/${areaId}/companies`)).data;
+}
+
+export async function listAreasForCompany(companyId: string) {
+  return (await apiRequest<{ data: OperationalAssetSummary[] }>(`/asset-operational-relations/companies/${companyId}/areas`)).data;
+}
+
+export async function listAreaCompanyRelations(params: {
+  areaId?: string;
+  companyId?: string;
+  includeHistory?: boolean;
+} = {}) {
+  const query = new URLSearchParams();
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.includeHistory) query.set('includeHistory', 'true');
+  const suffix = query.size ? `?${query}` : '';
+  return (await apiRequest<{ data: AreaCompanyRelation[] }>(`/asset-operational-relations${suffix}`)).data;
+}
+
+export function createAreaCompanyRelation(input: { areaId: string; companyId: string; relationRole?: AreaOrganizationRole; participationPercent?: number | null; legalInstrument?: string | null; sourceDocumentId?: string | null; reason: string }) {
+  return apiRequest<AreaCompanyRelation>('/asset-operational-relations', {
+    method: 'POST', body: JSON.stringify(input),
+  });
+}
+
+export function endAreaCompanyRelation(id: string, reason: string) {
+  return apiRequest<AreaCompanyRelation>(`/asset-operational-relations/${id}/end`, {
+    method: 'POST', body: JSON.stringify({ reason }),
+  });
+}
+
+export function createAssetType(input: {
+  code: string;
+  name: string;
+  description: string;
+  canBeRoot: boolean;
+  operationalRole: AssetTypeOperationalRole;
+  allowedParentTypeIds: string[];
+}) {
+  return apiRequest<AssetType>('/asset-types', {
+    method: 'POST', body: JSON.stringify(input),
+  });
+}
+
+export function updateAssetType(id: string, input: {
+  name?: string;
+  description?: string;
+  canBeRoot?: boolean;
+  isActive?: boolean;
+  operationalRole?: AssetTypeOperationalRole;
+  allowedParentTypeIds?: string[];
+}) {
+  return apiRequest<AssetType>(`/asset-types/${id}`, {
+    method: 'PATCH', body: JSON.stringify(input),
+  });
+}
+
+export function createAssetAttribute(typeId: string, input: {
+  code: string;
+  name: string;
+  dataType: AssetAttributeDataType;
+  isRequired: boolean;
+  unit?: string | null;
+  options?: string[];
+  sortOrder: number;
+}) {
+  return apiRequest<AssetType>(`/asset-types/${typeId}/attributes`, {
+    method: 'POST', body: JSON.stringify(input),
+  });
+}
+
+export function updateAssetAttribute(
+  typeId: string,
+  attributeId: string,
+  input: {
+    name?: string;
+    dataType?: AssetAttributeDataType;
+    isRequired?: boolean;
+    isActive?: boolean;
+    unit?: string | null;
+    options?: string[] | null;
+    sortOrder?: number;
+  },
+) {
+  return apiRequest<AssetType>(`/asset-types/${typeId}/attributes/${attributeId}`, {
+    method: 'PATCH', body: JSON.stringify(input),
+  });
+}
+
+export function listAssets(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  typeId?: string;
+  status?: AssetInformationStatus | '';
+  operationalStatus?: AssetOperationalStatus | '';
+  needsValidation?: boolean;
+  hasGeometry?: boolean;
+  parentId?: string;
+  operationalAreaId?: string;
+  operatorCompanyId?: string;
+} = {}) {
+  const query = new URLSearchParams();
+  query.set('page', String(params.page ?? 1));
+  query.set('pageSize', String(params.pageSize ?? 25));
+  if (params.search) query.set('search', params.search);
+  if (params.typeId) query.set('typeId', params.typeId);
+  if (params.status) query.set('status', params.status);
+  if (params.operationalStatus) query.set('operationalStatus', params.operationalStatus);
+  if (params.needsValidation !== undefined) query.set('needsValidation', String(params.needsValidation));
+  if (params.hasGeometry !== undefined) query.set('hasGeometry', String(params.hasGeometry));
+  if (params.parentId) query.set('parentId', params.parentId);
+  if (params.operationalAreaId) query.set('operationalAreaId', params.operationalAreaId);
+  if (params.operatorCompanyId) query.set('operatorCompanyId', params.operatorCompanyId);
+  return apiRequest<Page<AssetListItem>>(`/assets?${query}`);
+}
+
+export async function listAssetTree(params: {
+  search?: string;
+  typeId?: string;
+  status?: AssetInformationStatus | '';
+  operationalStatus?: AssetOperationalStatus | '';
+  operationalAreaId?: string;
+  operatorCompanyId?: string;
+  needsValidation?: boolean;
+  hasGeometry?: boolean;
+} = {}) {
+  const query = new URLSearchParams();
+  if (params.search) query.set('search', params.search);
+  if (params.typeId) query.set('typeId', params.typeId);
+  if (params.status) query.set('status', params.status);
+  if (params.operationalStatus) query.set('operationalStatus', params.operationalStatus);
+  if (params.operationalAreaId) query.set('operationalAreaId', params.operationalAreaId);
+  if (params.operatorCompanyId) query.set('operatorCompanyId', params.operatorCompanyId);
+  if (params.needsValidation !== undefined) query.set('needsValidation', String(params.needsValidation));
+  if (params.hasGeometry !== undefined) query.set('hasGeometry', String(params.hasGeometry));
+  const suffix = query.toString() ? `?${query}` : '';
+  return apiRequest<{ data: AssetListItem[]; meta: { count: number; truncated: boolean } }>(`/assets/tree${suffix}`);
+}
+
+export async function listAssetTreeChildren(params: {
+  parentId?: string; search?: string; typeId?: string; status?: AssetInformationStatus | '';
+  operationalStatus?: AssetOperationalStatus | ''; operationalAreaId?: string; operatorCompanyId?: string;
+  needsValidation?: boolean; hasGeometry?: boolean; limit?: number;
+} = {}) {
+  const query = new URLSearchParams();
+  if (params.parentId) query.set('parentId', params.parentId);
+  if (params.search) query.set('search', params.search);
+  if (params.typeId) query.set('typeId', params.typeId);
+  if (params.status) query.set('status', params.status);
+  if (params.operationalStatus) query.set('operationalStatus', params.operationalStatus);
+  if (params.operationalAreaId) query.set('operationalAreaId', params.operationalAreaId);
+  if (params.operatorCompanyId) query.set('operatorCompanyId', params.operatorCompanyId);
+  if (params.needsValidation !== undefined) query.set('needsValidation', String(params.needsValidation));
+  if (params.hasGeometry !== undefined) query.set('hasGeometry', String(params.hasGeometry));
+  query.set('limit', String(params.limit ?? 100));
+  return apiRequest<{ data: AssetListItem[]; meta: { count: number; hasMore: boolean; parentId: string | null } }>(`/assets/tree-children?${query}`);
+}
+
+export async function listAssetParentOptions(
+  childTypeId: string,
+  assetId?: string,
+  search?: string,
+) {
+  const query = new URLSearchParams({ childTypeId });
+  if (assetId) query.set('assetId', assetId);
+  if (search) query.set('search', search);
+  return (await apiRequest<{ data: AssetListItem[] }>(`/assets/parent-options?${query}`)).data;
+}
+
+export function getAsset(id: string) {
+  return apiRequest<AssetDetail>(`/assets/${id}`);
+}
+
+export function getAssetDossier(id: string) {
+  return apiRequest<AssetDossier>(`/assets/${id}/dossier`);
+}
+
+export async function getAssetLineage(id: string) {
+  return (await apiRequest<{ data: AssetLineageItem[] }>(`/assets/${id}/lineage`)).data;
+}
+
+export function createAsset(input: {
+  code: string;
+  name: string;
+  commonName?: string | null;
+  typeId: string;
+  parentId?: string | null;
+  operationalAreaId?: string | null;
+  operatorCompanyId?: string | null;
+  description?: string | null;
+  informationStatus?: AssetInformationStatus;
+  attributes: Record<string, unknown>;
+}) {
+  return apiRequest<AssetDetail>('/assets', {
+    method: 'POST', body: JSON.stringify(input),
+  });
+}
+
+export function updateAsset(id: string, input: {
+  typeId?: string;
+  code?: string;
+  name?: string;
+  commonName?: string | null;
+  parentId?: string | null;
+  operationalAreaId?: string | null;
+  operatorCompanyId?: string | null;
+  description?: string | null;
+  attributes?: Record<string, unknown>;
+}) {
+  return apiRequest<AssetDetail>(`/assets/${id}`, {
+    method: 'PATCH', body: JSON.stringify(input),
+  });
+}
+
+export function updateAssetInformationStatus(
+  id: string,
+  informationStatus: AssetInformationStatus,
+) {
+  return apiRequest<AssetDetail>(`/assets/${id}/information-status`, {
+    method: 'PATCH', body: JSON.stringify({ informationStatus }),
+  });
+}
+
+export function updateAssetOperationalStatus(id: string, status: AssetOperationalStatus) {
+  return apiRequest<AssetDetail>(`/assets/${id}/operational-status`, {
+    method: 'PATCH', body: JSON.stringify({ status }),
+  });
+}
+
+
+export async function listAssetContextHistory(assetId: string) {
+  return (await apiRequest<{ data: AssetContextHistoryItem[] }>(`/assets/${assetId}/context-history`)).data;
+}
+
+export function changeAssetContext(assetId: string, input: {
+  parentId?: string | null;
+  operationalAreaId?: string | null;
+  operatorCompanyId?: string | null;
+  effectiveAt?: string;
+  reason: string;
+}) {
+  return apiRequest<AssetDetail>(`/assets/${assetId}/context`, {
+    method: 'POST', body: JSON.stringify(input),
+  });
+}
+
+export function listFieldDiscoveries(params: { page?: number; pageSize?: number; status?: FieldDiscoveryStatus; search?: string } = {}) {
+  const query = new URLSearchParams();
+  query.set('page', String(params.page ?? 1));
+  query.set('pageSize', String(params.pageSize ?? 25));
+  if (params.status) query.set('status', params.status);
+  if (params.search) query.set('search', params.search);
+  return apiRequest<Page<FieldDiscovery>>(`/assets/field-discoveries?${query}`);
+}
+
+export function approveFieldDiscovery(id: string, notes?: string | null) {
+  return apiRequest<FieldDiscovery>(`/assets/field-discoveries/${id}/approve`, { method: 'POST', body: JSON.stringify({ notes: notes || null }) });
+}
+
+export function rejectFieldDiscovery(id: string, reason: string) {
+  return apiRequest<FieldDiscovery>(`/assets/field-discoveries/${id}/reject`, { method: 'POST', body: JSON.stringify({ reason }) });
+}
+
+export function matchFieldDiscovery(id: string, matchedAssetId: string, reason: string) {
+  return apiRequest<FieldDiscovery>(`/assets/field-discoveries/${id}/match`, { method: 'POST', body: JSON.stringify({ matchedAssetId, reason }) });
+}
+
+export function getAssetRegistry(assetId: string) {
+  return apiRequest<AssetRegistry>(`/assets/${assetId}/registry`);
+}
+export async function listSourceDocuments(search = '') {
+  const suffix = search.trim() ? `?search=${encodeURIComponent(search.trim())}` : '';
+  return (await apiRequest<{ data: SourceDocumentSummary[] }>(`/source-documents${suffix}`)).data;
+}
+export function createSourceDocument(input: { documentType: SourceDocumentType; documentNumber?: string | null; title: string; issuer?: string | null; documentDate?: string | null; externalReference?: string | null; notes?: string | null }) {
+  return apiRequest<SourceDocumentSummary>('/source-documents', { method: 'POST', body: JSON.stringify(input) });
+}
+export function linkAssetSourceDocument(assetId: string, documentId: string, input: { relationType: AssetSourceDocumentRelationType; notes?: string | null }) {
+  return apiRequest(`/assets/${assetId}/source-documents/${documentId}`, { method: 'POST', body: JSON.stringify(input) });
+}
+export function addAssetExternalIdentifier(assetId: string, input: { namespace: string; value: string; validFrom?: string | null; sourceDocumentId?: string | null; notes?: string | null }) {
+  return apiRequest(`/assets/${assetId}/external-identifiers`, { method: 'POST', body: JSON.stringify(input) });
+}
+export function endAssetExternalIdentifier(id: string, reason: string) {
+  return apiRequest(`/asset-external-identifiers/${id}/end`, { method: 'POST', body: JSON.stringify({ reason }) });
+}
+export function upsertOrganizationProfile(assetId: string, input: { organizationKind: OrganizationKind; legalName?: string | null; taxId?: string | null; notificationEmail?: string | null; notes?: string | null }) {
+  return apiRequest(`/assets/${assetId}/organization-profile`, { method: 'PATCH', body: JSON.stringify(input) });
+}
+export function addOrganizationMembership(organizationId: string, input: { memberOrganizationId: string; role: OrganizationMembershipRole; participationPercent?: number | null; validFrom?: string | null; sourceDocumentId?: string | null; notes?: string | null }) {
+  return apiRequest(`/organizations/${organizationId}/memberships`, { method: 'POST', body: JSON.stringify(input) });
+}
+export function endOrganizationMembership(id: string, reason: string) {
+  return apiRequest(`/organization-memberships/${id}/end`, { method: 'POST', body: JSON.stringify({ reason }) });
+}
+export function createAreaLegalRight(areaId: string, input: { rightType: AreaLegalRightType; name: string; instrumentNumber?: string | null; validFrom?: string | null; validUntil?: string | null; status?: AreaLegalRightStatus; sourceDocumentId?: string | null; notes?: string | null }) {
+  return apiRequest(`/areas/${areaId}/legal-rights`, { method: 'POST', body: JSON.stringify(input) });
+}
+export function addAreaLegalRightOrganization(rightId: string, input: { organizationId: string; role: AreaLegalRightOrganizationRole; participationPercent?: number | null; validFrom?: string | null; notes?: string | null }) {
+  return apiRequest(`/area-legal-rights/${rightId}/organizations`, { method: 'POST', body: JSON.stringify(input) });
+}
+export function endAreaLegalRightOrganization(id: string, reason: string) {
+  return apiRequest(`/area-legal-right-organizations/${id}/end`, { method: 'POST', body: JSON.stringify({ reason }) });
+}
+
+export async function getAssetGeometry(assetId: string) {
+  return (await apiRequest<{ data: AssetGeometry | null }>(`/assets/${assetId}/geometry`)).data;
+}
+
+export function upsertAssetGeometry(assetId: string, input: {
+  geometry: GeoJsonGeometry;
+  accuracyM?: number | null;
+  capturedAt?: string | null;
+  deviceLabel?: string | null;
+}) {
+  return apiRequest<AssetGeometry>(`/assets/${assetId}/geometry`, {
+    method: 'PUT', body: JSON.stringify(input),
+  });
+}
+
+export function removeAssetGeometry(assetId: string) {
+  return apiRequest<{ status: 'removed' | 'absent' }>(`/assets/${assetId}/geometry`, {
+    method: 'DELETE',
+  });
+}
+
+export function getMapAssets(params: {
+  bbox?: string;
+  typeId?: string;
+  status?: AssetInformationStatus | '';
+  geometryType?: AssetGeometryType | '';
+} = {}) {
+  const query = new URLSearchParams();
+  if (params.bbox) query.set('bbox', params.bbox);
+  if (params.typeId) query.set('typeId', params.typeId);
+  if (params.status) query.set('status', params.status);
+  if (params.geometryType) query.set('geometryType', params.geometryType);
+  const suffix = query.size ? `?${query}` : '';
+  return apiRequest<MapAssetFeatureCollection>(`/map/assets${suffix}`);
+}
+
+export function listAssetVersions(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  typeId?: string;
+  status?: AssetInformationStatus | '';
+  changeType?: AssetVersionChangeType | '';
+  from?: string;
+  to?: string;
+} = {}) {
+  const query = new URLSearchParams();
+  query.set('page', String(params.page ?? 1));
+  query.set('pageSize', String(params.pageSize ?? 25));
+  if (params.search) query.set('search', params.search);
+  if (params.typeId) query.set('typeId', params.typeId);
+  if (params.status) query.set('status', params.status);
+  if (params.changeType) query.set('changeType', params.changeType);
+  if (params.from) query.set('from', params.from);
+  if (params.to) query.set('to', params.to);
+  return apiRequest<Page<AssetVersionSummary>>(`/asset-versions?${query}`);
+}
+
+export function listAssetVersionTimeline(
+  assetId: string,
+  params: { page?: number; pageSize?: number } = {},
+) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 10),
+  });
+  return apiRequest<Page<AssetVersionSummary>>(`/assets/${assetId}/versions?${query}`);
+}
+
+export function getAssetVersion(assetId: string, versionNumber: number) {
+  return apiRequest<AssetVersionDetail>(`/assets/${assetId}/versions/${versionNumber}`);
+}
+
+export async function listAssetMedia(assetId: string) {
+  return (await apiRequest<{ data: AssetMedia[] }>(`/assets/${assetId}/media`)).data;
+}
+
+export function uploadAssetMedia(assetId: string, input: {
+  file: File;
+  kind: AssetMediaKind;
+  title?: string;
+  description?: string;
+  capturedAt?: string;
+  latitude?: number;
+  longitude?: number;
+  accuracyM?: number;
+}) {
+  const body = new FormData();
+  body.append('file', input.file);
+  body.append('kind', input.kind);
+  if (input.title) body.append('title', input.title);
+  if (input.description) body.append('description', input.description);
+  if (input.capturedAt) body.append('capturedAt', input.capturedAt);
+  if (input.latitude !== undefined) body.append('latitude', String(input.latitude));
+  if (input.longitude !== undefined) body.append('longitude', String(input.longitude));
+  if (input.accuracyM !== undefined) body.append('accuracyM', String(input.accuracyM));
+  return apiRequest<AssetMedia>(`/assets/${assetId}/media`, {
+    method: 'POST',
+    body,
+  });
+}
+
+export function updateAssetMedia(mediaId: string, input: {
+  title?: string | null;
+  description?: string | null;
+  capturedAt?: string | null;
+  latitude?: number | null;
+  longitude?: number | null;
+  accuracyM?: number | null;
+}) {
+  return apiRequest<AssetMedia>(`/asset-media/${mediaId}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export function removeAssetMedia(mediaId: string) {
+  return apiRequest<{ status: 'removed' }>(`/asset-media/${mediaId}`, {
+    method: 'DELETE',
+  });
+}
+
+export function getAssetMediaBlob(mediaId: string, download = false) {
+  return apiBlobRequest(`/asset-media/${mediaId}/content${download ? '?download=1' : ''}`);
+}
+
+export function getAssetProvenance(assetId: string) {
+  return apiRequest<AssetProvenance>(`/assets/${assetId}/provenance`);
+}
+
+export function updateAssetProvenance(assetId: string, input: {
+  origin: AssetDataOrigin;
+  sourceName?: string | null;
+  sourceReference?: string | null;
+  observedAt?: string | null;
+  notes?: string | null;
+}) {
+  return apiRequest<AssetProvenance>(`/assets/${assetId}/provenance`, {
+    method: 'PUT',
+    body: JSON.stringify(input),
+  });
+}
+
+export function verifyAssetProvenance(assetId: string) {
+  return apiRequest<AssetProvenance>(`/assets/${assetId}/provenance/verify`, {
+    method: 'POST',
+  });
+}
+
+export function listTemporalAssets(params: {
+  at: string;
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  typeId?: string;
+  status?: AssetInformationStatus | '';
+}) {
+  const query = new URLSearchParams({
+    at: params.at,
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.typeId) query.set('typeId', params.typeId);
+  if (params.status) query.set('status', params.status);
+  return apiRequest<Page<TemporalAssetSummary> & { asOf: string }>(
+    `/temporal-assets?${query}`,
+  );
+}
+
+export function getTemporalAsset(assetId: string, at: string) {
+  const query = new URLSearchParams({ at });
+  return apiRequest<TemporalAssetDetail>(`/temporal-assets/${assetId}?${query}`);
+}
+
+export function listSurveyCampaigns(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: SurveyCampaignStatus | '';
+  coordinatorUserId?: string;
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.status) query.set('status', params.status);
+  if (params.coordinatorUserId) query.set('coordinatorUserId', params.coordinatorUserId);
+  return apiRequest<Page<SurveyCampaignListItem>>(`/survey-campaigns?${query}`);
+}
+
+export function getSurveyCampaign(id: string) {
+  return apiRequest<SurveyCampaign>(`/survey-campaigns/${id}`);
+}
+
+export async function listSurveyAssignees() {
+  return (await apiRequest<{ data: SurveyPerson[] }>('/survey-campaigns/assignees')).data;
+}
+
+export function createSurveyCampaign(input: {
+  code: string;
+  name: string;
+  description?: string | null;
+  plannedStartAt?: string | null;
+  plannedEndAt?: string | null;
+  scopeAssetId?: string | null;
+  coordinatorUserId?: string | null;
+}) {
+  return apiRequest<SurveyCampaign>('/survey-campaigns', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function updateSurveyCampaign(id: string, input: {
+  code?: string;
+  name?: string;
+  description?: string | null;
+  plannedStartAt?: string | null;
+  plannedEndAt?: string | null;
+  scopeAssetId?: string | null;
+  coordinatorUserId?: string | null;
+}) {
+  return apiRequest<SurveyCampaign>(`/survey-campaigns/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export function updateSurveyCampaignStatus(id: string, status: SurveyCampaignStatus) {
+  return apiRequest<SurveyCampaign>(`/survey-campaigns/${id}/status`, {
+    method: 'PUT',
+    body: JSON.stringify({ status }),
+  });
+}
+
+export function addSurveyTarget(campaignId: string, input: {
+  assetId: string;
+  assignedUserId?: string | null;
+  dueAt?: string | null;
+  instructions?: string | null;
+}) {
+  return apiRequest<SurveyCampaign>(`/survey-campaigns/${campaignId}/targets`, {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function updateSurveyTarget(id: string, input: {
+  dueAt?: string | null;
+  instructions?: string | null;
+}) {
+  return apiRequest<SurveyCampaign>(`/survey-campaign-targets/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export function assignSurveyTarget(id: string, assignedUserId: string | null) {
+  return apiRequest<SurveyCampaign>(`/survey-campaign-targets/${id}/assignment`, {
+    method: 'PUT',
+    body: JSON.stringify({ assignedUserId }),
+  });
+}
+
+export function updateSurveyTargetStatus(id: string, status: SurveyTargetStatus) {
+  return apiRequest<SurveyCampaign>(`/survey-campaign-targets/${id}/status`, {
+    method: 'PUT',
+    body: JSON.stringify({ status }),
+  });
+}
+
+export function getSurveyExecution(targetId: string) {
+  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report`);
+}
+
+export function saveSurveyReport(targetId: string, input: {
+  outcome: SurveyReportOutcome | null;
+  observedAt: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  accuracyM: number | null;
+  notes: string | null;
+  mediaIds: string[];
+}) {
+  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report`, {
+    method: 'PUT',
+    body: JSON.stringify(input),
+  });
+}
+
+export function submitSurveyReport(targetId: string) {
+  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report/submit`, {
+    method: 'POST',
+  });
+}
+
+export function reviewSurveyReport(
+  targetId: string,
+  decision: 'APPROVE' | 'REJECT',
+  notes: string | null,
+) {
+  return apiRequest<SurveyExecution>(`/survey-campaign-targets/${targetId}/report/review`, {
+    method: 'POST',
+    body: JSON.stringify({ decision, notes }),
+  });
+}
+
+export function listInspectionVisits(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: InspectionVisitStatus | '';
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.status) query.set('status', params.status);
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
+  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
+  if (params.dateTo) query.set('dateTo', params.dateTo);
+  return apiRequest<Page<InspectionVisitListItem>>(`/inspection-visits?${query}`);
+}
+
+export function getInspectionVisit(id: string) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}`);
+}
+
+export async function listInspectionAssignees() {
+  return (await apiRequest<{ data: InspectionPerson[] }>('/inspection-visits/assignees')).data;
+}
+
+export async function listInspectionPlanningAreas() {
+  return (await apiRequest<{ data: InspectionPlanningContextAsset[] }>('/inspection-visits/planning-context/areas')).data;
+}
+
+export async function listInspectionPlanningOperators(areaId: string) {
+  return (await apiRequest<{ data: InspectionPlanningContextAsset[] }>(`/inspection-visits/planning-context/areas/${areaId}/operators`)).data;
+}
+
+export function createInspectionVisit(input: {
+  operationalAreaId: string;
+  operatorCompanyId: string;
+  plannedStartAt: string;
+  leadInspectorUserId: string;
+}) {
+  return apiRequest<InspectionVisit>('/inspection-visits', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function updateInspectionVisit(id: string, input: {
+  objective?: string | null;
+  scopeAssetId?: string | null;
+  operationalAreaId?: string | null;
+  operatorCompanyId?: string | null;
+  plannedStartAt?: string | null;
+  instructions?: string | null;
+}) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export function replaceInspectionVisitAssets(id: string, assetIds: string[]) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/assets`, {
+    method: 'PUT',
+    body: JSON.stringify({ assetIds }),
+  });
+}
+
+export function generateInspectionVisitChecklist(id: string) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/checklist/generate`, {
+    method: 'POST',
+  });
+}
+
+export function excludeInspectionVisitAsset(id: string, assetId: string, reason: string) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/assets/${assetId}/exclude`, {
+    method: 'POST',
+    body: JSON.stringify({ reason }),
+  });
+}
+
+export function includeInspectionVisitAsset(id: string, assetId: string) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/assets/${assetId}/include`, {
+    method: 'POST',
+  });
+}
+
+export function replaceInspectionVisitTeam(
+  id: string,
+  leadInspectorUserId: string | null,
+  memberUserIds: string[],
+) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/team`, {
+    method: 'PUT',
+    body: JSON.stringify({ leadInspectorUserId, memberUserIds }),
+  });
+}
+
+export function updateInspectionVisitStatus(
+  id: string,
+  status: InspectionVisitStatus,
+  reason?: string | null,
+) {
+  return apiRequest<InspectionVisit>(`/inspection-visits/${id}/status`, {
+    method: 'PUT',
+    body: JSON.stringify({ status, reason: reason ?? null }),
+  });
+}
+
+export function listInspectionActs(visitId: string, params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: InspectionActStatus | '';
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.status) query.set('status', params.status);
+  return apiRequest<Page<InspectionActListItem>>(
+    `/inspection-visits/${visitId}/acts?${query}`,
+  );
+}
+
+export function listInspectionActsGlobal(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: InspectionActStatus | '';
+  year?: number | '';
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.status) query.set('status', params.status);
+  if (params.year) query.set('year', String(params.year));
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
+  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
+  if (params.dateTo) query.set('dateTo', params.dateTo);
+  return apiRequest<Page<InspectionActListItem>>(`/inspection-acts?${query}`);
+}
+
+export function listInspectionReports(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  year?: number | '';
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.year) query.set('year', String(params.year));
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
+  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
+  if (params.dateTo) query.set('dateTo', params.dateTo);
+  return apiRequest<Page<InspectionReportListItem>>(`/inspection-reports?${query}`);
+}
+
+export function listPendingInspectionReports(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  year?: number | '';
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.year) query.set('year', String(params.year));
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
+  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
+  if (params.dateTo) query.set('dateTo', params.dateTo);
+  return apiRequest<Page<PendingInspectionReportItem>>(`/inspection-reports/pending?${query}`);
+}
+
+export function getInspectionReport(id: string) {
+  return apiRequest<InspectionReport>(`/inspection-reports/${id}`);
+}
+
+export function getInspectionReportReview(id: string) {
+  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review`);
+}
+
+export function uploadInspectionReportRevision(id: string, file: File, changeSummary: string) {
+  const form = new FormData();
+  form.append('file', file);
+  form.append('changeSummary', changeSummary);
+  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review/revisions`, { method: 'POST', body: form });
+}
+
+export function approveInspectionReport(id: string, note?: string) {
+  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review/approve`, { method: 'POST', body: JSON.stringify({ note: note?.trim() || undefined }) });
+}
+
+export function signFinalInspectionReport(id: string) {
+  return apiRequest<InspectionReportReview>(`/inspection-reports/${id}/review/sign-final`, { method: 'POST', body: JSON.stringify({ confirmation: true }) });
+}
+
+export function inspectionReportRevisionUrl(revisionId: string) {
+  return `${API_BASE}/inspection-report-revisions/${revisionId}/content`;
+}
+
+export function getInspectionAct(id: string) {
+  return apiRequest<InspectionAct>(`/inspection-acts/${id}`);
+}
+
+export function getInspectionClosure(actId: string) {
+  return apiRequest<InspectionClosure>(`/inspection-acts/${actId}/closure`);
+}
+
+export function getInspectionSignatureBlob(signatureId: string) {
+  return apiBlobRequest(`/inspection-act-signatures/${signatureId}/content`);
+}
+
+export function getFindingCatalog(params: { categoryId?: string; search?: string } = {}) {
+  const query = new URLSearchParams();
+  if (params.categoryId) query.set('categoryId', params.categoryId);
+  if (params.search) query.set('search', params.search);
+  return apiRequest<FindingCatalog>(`/finding-catalog${query.size ? `?${query}` : ''}`);
+}
+
+export function getFindingCatalogAdmin() {
+  return apiRequest<FindingAdminCatalog>('/finding-catalog/admin');
+}
+
+export function getApplicableFindingCatalog(assetId: string, params: { categoryId?: string; search?: string } = {}) {
+  const query = new URLSearchParams();
+  if (params.categoryId) query.set('categoryId', params.categoryId);
+  if (params.search) query.set('search', params.search);
+  return apiRequest<FindingCatalogApplicable>(`/finding-catalog/applicable/${assetId}${query.size ? `?${query}` : ''}`);
+}
+
+export function getFindingCatalogAssetTypeSelection(assetTypeId: string) {
+  return apiRequest<FindingCatalogAssetTypeSelection>(`/finding-catalog/asset-types/${assetTypeId}/selection`);
+}
+
+export function replaceFindingCatalogAssetTypeSelection(assetTypeId: string, input: { enabledItemIds: string[]; reason: string }) {
+  return apiRequest<FindingCatalogAssetTypeSelection>(`/finding-catalog/asset-types/${assetTypeId}/selection`, {
+    method: 'PUT',
+    body: JSON.stringify(input),
+  });
+}
+
+export function getFindingCatalogAssetSelection(assetId: string) {
+  return apiRequest<FindingCatalogAssetSelection>(`/finding-catalog/assets/${assetId}/selection`);
+}
+
+export function replaceFindingCatalogAssetSelection(assetId: string, input: { enabledItemIds: string[]; reason: string }) {
+  return apiRequest<FindingCatalogAssetSelection>(`/finding-catalog/assets/${assetId}/selection`, {
+    method: 'PUT',
+    body: JSON.stringify(input),
+  });
+}
+
+export function listFindingCatalogProposals(params: { status?: FindingCatalogProposalStatus; assetTypeId?: string } = {}) {
+  const query = new URLSearchParams();
+  if (params.status) query.set('status', params.status);
+  if (params.assetTypeId) query.set('assetTypeId', params.assetTypeId);
+  return apiRequest<FindingCatalogProposal[]>(`/finding-catalog/proposals${query.size ? `?${query}` : ''}`);
+}
+
+export function reviewFindingCatalogProposal(id: string, input: {
+  decision: 'MATCH' | 'REJECT';
+  catalogItemId?: string;
+  notes?: string | null;
+}) {
+  return apiRequest<FindingCatalogProposal>(`/finding-catalog/proposals/${id}/review`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export function createFindingCategory(input: {
+  code: string;
+  name: string;
+  sortOrder: number;
+}) {
+  return apiRequest<FindingAdminCategory>('/finding-catalog/categories', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function updateFindingCategory(id: string, input: {
+  name?: string;
+  sortOrder?: number;
+  isActive?: boolean;
+}) {
+  return apiRequest<FindingAdminCategory>(`/finding-catalog/categories/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export interface FindingCatalogItemInput {
+  categoryId: string;
+  sourceNumber: number;
+  title: string;
+  legalBasis?: string | null;
+  glossary?: string | null;
+  importNote?: string | null;
+  suggestedSeverity?: number | null;
+}
+
+export function createFindingCatalogItem(input: FindingCatalogItemInput & { code: string }) {
+  return apiRequest<FindingAdminCatalogItem>('/finding-catalog/items', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function updateFindingCatalogItem(id: string, input: FindingCatalogItemInput & {
+  isActive: boolean;
+}) {
+  return apiRequest<FindingAdminCatalogItem>(`/finding-catalog/items/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export async function listInspectionFindings(actId: string) {
+  return (await apiRequest<{ data: InspectionFinding[] }>(
+    `/inspection-acts/${actId}/findings`,
+  )).data;
+}
+
+export function listInspectionFindingsGlobal(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  workflow?: InspectionFindingWorkflow;
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.workflow) query.set('workflow', params.workflow);
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
+  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
+  if (params.dateTo) query.set('dateTo', params.dateTo);
+  return apiRequest<InspectionFindingGlobalPage>(`/inspection-findings?${query}`);
+}
+
+export function getInspectionFinding(id: string) {
+  return apiRequest<InspectionFinding>(`/inspection-findings/${id}`);
+}
+
+export function getInspectionFindingVerificationHistory(id: string) {
+  return apiRequest<InspectionFindingVerificationEvent[]>(`/inspection-findings/${id}/verification-history`);
+}
+
+export function listVerificationPlanning(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  planningStatus?: VerificationPlanningStatus;
+  companyId?: string;
+  areaId?: string;
+  dueFrom?: string;
+  dueTo?: string;
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 50),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.planningStatus) query.set('planningStatus', params.planningStatus);
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.dueFrom) query.set('dueFrom', params.dueFrom);
+  if (params.dueTo) query.set('dueTo', params.dueTo);
+  return apiRequest<VerificationPlanningPage>(`/inspection-verifications?${query}`);
+}
+
+export function planVerificationVisit(input: {
+  findingIds: string[];
+  plannedStartAt: string;
+  notes?: string | null;
+}) {
+  return apiRequest<PlannedVerificationVisitResult>('/inspection-verifications/plan', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export function recordVerificationResult(visitId: string, findingId: string, input: {
+  outcome: InspectionVerificationOutcome;
+  notes: string;
+  verifiedAt?: string;
+  nextControlOn?: string;
+}) {
+  return apiRequest<{
+    findingId: string;
+    visitId: string;
+    targetControlOn: string | null;
+    outcome: InspectionVerificationOutcome;
+    notes: string;
+    verifiedAt: string;
+    recordedAt: string;
+    rescheduledControlOn: string | null;
+    nextControlOn: string | null;
+    findingStatus: InspectionFindingStatus;
+    visitStatus: InspectionVisitStatus;
+  }>(`/inspection-verifications/visits/${visitId}/findings/${findingId}/result`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export function closeInspectionFinding(id: string, closureNotes: string) {
+  return apiRequest<InspectionFinding>(`/inspection-findings/${id}/close`, {
+    method: 'PATCH',
+    body: JSON.stringify({ closureNotes }),
+  });
+}
+
+export function updateInspectionFindingFollowUp(id: string, input: {
+  responseDueBasis?: 'FINDING_DATE' | 'REPORT_NOTIFICATION' | null;
+  responseDueDays?: number | null;
+  reportNotifiedOn?: string | null;
+  companyResponse?: string | null;
+  companyResponseReceivedOn?: string | null;
+  companyCommittedCorrectionOn?: string | null;
+  nextControlOn?: string | null;
+}) {
+  return apiRequest<InspectionFinding>(`/inspection-findings/${id}/follow-up`, {
+    method: 'PATCH',
+    body: JSON.stringify(input),
+  });
+}
+
+export async function listInspectionFindingEvidence(findingId: string) {
+  return (await apiRequest<{ data: InspectionFindingEvidence[] }>(
+    `/inspection-findings/${findingId}/evidence`,
+  )).data;
+}
+
+export function uploadInspectionFindingEvidence(findingId: string, input: {
+  file: File;
+  kind: InspectionEvidenceKind;
+  purpose: InspectionEvidencePurpose;
+  communicationId?: string;
+  verificationVisitId?: string;
+  title?: string;
+  description?: string;
+  capturedAt?: string;
+  latitude?: number;
+  longitude?: number;
+  accuracyM?: number;
+  deviceLabel?: string;
+}) {
+  const body = new FormData();
+  body.append('file', input.file);
+  body.append('kind', input.kind);
+  body.append('purpose', input.purpose);
+  if (input.communicationId) body.append('communicationId', input.communicationId);
+  if (input.verificationVisitId) body.append('verificationVisitId', input.verificationVisitId);
+  if (input.title) body.append('title', input.title);
+  if (input.description) body.append('description', input.description);
+  if (input.capturedAt) body.append('capturedAt', input.capturedAt);
+  if (input.latitude !== undefined) body.append('latitude', String(input.latitude));
+  if (input.longitude !== undefined) body.append('longitude', String(input.longitude));
+  if (input.accuracyM !== undefined) body.append('accuracyM', String(input.accuracyM));
+  if (input.deviceLabel) body.append('deviceLabel', input.deviceLabel);
+  return apiRequest<InspectionFindingEvidence>(
+    `/inspection-findings/${findingId}/evidence`,
+    { method: 'POST', body },
+  );
+}
+
+export function getInspectionFindingEvidenceBlob(evidenceId: string, download = false) {
+  return apiBlobRequest(
+    `/inspection-finding-evidence/${evidenceId}/content${download ? '?download=1' : ''}`,
+  );
+}
+
+export async function listInspectionFindingCommunications(findingId: string) {
+  return (await apiRequest<{ data: InspectionFindingCommunication[] }>(
+    `/inspection-findings/${findingId}/communications`,
+  )).data;
+}
+
+export function createInspectionFindingCommunication(findingId: string, input: {
+  direction: InspectionFindingCommunication['direction'];
+  channel: InspectionFindingCommunication['channel'];
+  type: InspectionFindingCommunication['type'];
+  occurredAt: string;
+  subject: string;
+  details?: string | null;
+  contactName?: string | null;
+  contactEmail?: string | null;
+}) {
+  return apiRequest<InspectionFindingCommunication>(
+    `/inspection-findings/${findingId}/communications`,
+    { method: 'POST', body: JSON.stringify(input) },
+  );
+}
+
+export function listAssetImportBatches(params: { page?: number; pageSize?: number; status?: AssetImportBatchStatus | '' } = {}) {
+  const query = new URLSearchParams({ page: String(params.page ?? 1), pageSize: String(params.pageSize ?? 20) });
+  if (params.status) query.set('status', params.status);
+  return apiRequest<Page<AssetImportBatch>>(`/asset-imports?${query}`);
+}
+
+export function listAssetImportReviews(params: { page?: number; pageSize?: number; kind?: 'ALL' | 'DIRECT' | 'DEPENDENCY' } = {}) {
+  const query = new URLSearchParams();
+  if (params.page) query.set('page', String(params.page));
+  if (params.pageSize) query.set('pageSize', String(params.pageSize));
+  if (params.kind && params.kind !== 'ALL') query.set('kind', params.kind);
+  const suffix = query.toString() ? `?${query}` : '';
+  return apiRequest<{ data: AssetImportReviewItem[]; meta: { page: number; pageSize: number; total: number; totalPages: number } }>(`/asset-imports/reviews${suffix}`);
+}
+
+export function getAssetImportBatch(id: string) {
+  return apiRequest<AssetImportBatchDetail>(`/asset-imports/${id}`);
+}
+
+export function listAssetImportRows(id: string, params: { page?: number; pageSize?: number; status?: AssetImportRowStatus | ''; search?: string } = {}) {
+  const query = new URLSearchParams({ page: String(params.page ?? 1), pageSize: String(params.pageSize ?? 50) });
+  if (params.status) query.set('status', params.status);
+  if (params.search) query.set('search', params.search);
+  return apiRequest<Page<AssetImportRow>>(`/asset-imports/${id}/rows?${query}`);
+}
+
+export function uploadAssetImport(input: { file: File; sourceLabel?: string; notes?: string; profileCode?: Exclude<AssetImportProfileCode, 'UNKNOWN'> }) {
+  const body = new FormData();
+  body.append('file', input.file);
+  if (input.sourceLabel?.trim()) body.append('sourceLabel', input.sourceLabel.trim());
+  if (input.notes?.trim()) body.append('notes', input.notes.trim());
+  if (input.profileCode) body.append('profileCode', input.profileCode);
+  return apiRequest<AssetImportBatch>('/asset-imports', { method: 'POST', body });
+}
+
+export function reconcileAssetImport(id: string) {
+  return apiRequest<AssetImportBatch>(`/asset-imports/${id}/reconcile`, { method: 'POST' });
+}
+
+export function listAssetImportOrganizations(search?: string) {
+  const query = new URLSearchParams();
+  if (search?.trim()) query.set('search', search.trim());
+  const suffix = query.toString() ? `?${query}` : '';
+  return apiRequest<{ data: AssetImportOrganizationOption[] }>(`/asset-imports/context/organizations${suffix}`);
+}
+
+export function getAssetImportPlan(id: string) {
+  return apiRequest<AssetImportPlan | null>(`/asset-imports/${id}/plan`);
+}
+
+export function generateAssetImportPlan(id: string, input: { operatorAssetId?: string; externalIdNamespace?: string }) {
+  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/plan`, { method: 'POST', body: JSON.stringify(input) });
+}
+
+export function listAssetImportPlanItems(id: string, input: { entityKind?: AssetImportPlanEntityKind; action?: AssetImportPlanAction; page?: number; pageSize?: number } = {}) {
+  const query = new URLSearchParams();
+  if (input.entityKind) query.set('entityKind', input.entityKind);
+  if (input.action) query.set('action', input.action);
+  if (input.page) query.set('page', String(input.page));
+  if (input.pageSize) query.set('pageSize', String(input.pageSize));
+  const suffix = query.toString() ? `?${query}` : '';
+  return apiRequest<{ data: AssetImportPlanItem[]; meta: { page: number; pageSize: number; total: number; totalPages: number } }>(`/asset-imports/${id}/plan/items${suffix}`);
+}
+
+export function resolveAssetImportPlanItem(id: string, itemId: string, input: { action: 'CREATE' | 'MATCH' | 'IGNORE'; matchedAssetId?: string; reason: string }) {
+  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/plan/items/${itemId}/resolve`, { method: 'POST', body: JSON.stringify(input) });
+}
+
+export function applySafeAssetImportPlan(id: string, planHash: string) {
+  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/apply-safe`, { method: 'POST', body: JSON.stringify({ planHash }) });
+}
+
+export function applyAssetImportPlan(id: string, planHash: string) {
+  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/apply`, { method: 'POST', body: JSON.stringify({ planHash }) });
+}
+
+export function rollbackAssetImportPlan(id: string, reason: string) {
+  return apiRequest<AssetImportPlan>(`/asset-imports/${id}/rollback`, { method: 'POST', body: JSON.stringify({ reason }) });
+}
+
+export function cancelAssetImport(id: string, reason: string) {
+  return apiRequest<AssetImportBatch>(`/asset-imports/${id}/cancel`, { method: 'POST', body: JSON.stringify({ reason }) });
+}
+
+
+export function inspectionReportWordUrl(id: string) {
+  return `${API_BASE}/inspection-reports/${id}/word`;
+}
+
+export function generateInspectionReportWord(id: string) {
+  return apiRequest<InspectionReport>(`/inspection-reports/${id}/word`, { method: 'POST' });
+}
+
+
+export interface DocumentDeliverySettings { officeEmail:string|null; directorEmail:string|null; updatedAt:string; smtpConfigured:boolean; mailFrom:string|null; }
+export interface DocumentDeliveryItem { id:string; actId:string; reportId:string|null; documentKind:'ACT_PDF'|'REPORT_WORD'; recipientKind:'COMPANY'|'OFFICE'|'DIRECTOR'; recipientAssetId:string|null; recipientAssetName:string|null; recipientEmail:string|null; status:'PENDING'|'WAITING_RECIPIENT'|'WAITING_TRANSPORT'|'WAITING_ARTIFACT'|'SENT'|'FAILED'; attempts:number; lastAttemptAt:string|null; sentAt:string|null; providerMessageId:string|null; lastError:string|null; createdAt:string; actCode:string; reportCode:string|null; }
+export function getDocumentDeliverySettings(){return apiRequest<DocumentDeliverySettings>('/document-delivery/settings');}
+export function updateDocumentDeliverySettings(input:{officeEmail?:string|null;directorEmail?:string|null}){return apiRequest<DocumentDeliverySettings>('/document-delivery/settings',{method:'PATCH',body:JSON.stringify(input)});}
+export function listDocumentDeliveries(){return apiRequest<{data:DocumentDeliveryItem[]}>('/document-delivery/outbox');}
+export function retryDocumentDelivery(id:string){return apiRequest<DocumentDeliveryItem>(`/document-delivery/outbox/${id}/retry`,{method:'POST'});}
+export function retryPendingDocumentDeliveries(){return apiRequest<{processed:number}>('/document-delivery/outbox/retry-pending',{method:'POST'});}
+
+export type ActAdministrationState = 'NEW' | 'WAITING_RESPONSE' | 'DUE_SOON' | 'OVERDUE' | 'RESPONSE_RECEIVED' | 'VERIFICATION_PENDING' | 'COMMITMENT_OVERDUE' | 'REGULARIZED';
+export interface ActAdministrationQueueItem {
+  actId: string; actCode: string; actStatus: string; occurredAt: string; closedAt: string | null;
+  visitId: string; visitCode: string; areaId: string | null; companyId: string | null; areaName: string | null; companyName: string | null;
+  responseDueOn: string | null; deadlineReason: string | null; responseReceivedOn: string | null; committedCorrectionOn: string | null;
+  findingCount: number; openFindingCount: number; scheduledControlCount: number; adminState: ActAdministrationState;
+}
+export interface ActAdministrationQueuePage { data: ActAdministrationQueueItem[]; counters: Partial<Record<ActAdministrationState, number>>; meta: PageMeta }
+export interface ActAdministrationDetail {
+  act: ActAdministrationQueueItem;
+  deadlines: Array<{ id:string; responseDueOn:string; reason:string; createdAt:string }>;
+  responses: Array<{ id:string; receivedOn:string; details:string|null; committedCorrectionOn:string|null; contactName:string|null; contactEmail:string|null; originalName:string|null; sizeBytes:number|null; sha256:string|null; createdAt:string }>;
+  findings: Array<{ id:string; code:string; title:string; status:string; nextControlOn:string|null }>;
+}
+export function listActAdministrationQueue(params: { state?: ActAdministrationState | 'ALL'; areaId?: string; companyId?: string; page?: number; pageSize?: number } = {}) {
+  const q = new URLSearchParams({ page: String(params.page ?? 1), pageSize: String(params.pageSize ?? 25) });
+  if (params.state && params.state !== 'ALL') q.set('state', params.state);
+  if (params.areaId) q.set('areaId', params.areaId);
+  if (params.companyId) q.set('companyId', params.companyId);
+  return apiRequest<ActAdministrationQueuePage>(`/act-administration/queue?${q}`);
+}
+export function getActAdministration(actId: string) { return apiRequest<ActAdministrationDetail>(`/inspection-acts/${actId}/administration`); }
+export function setActResponseDeadline(actId: string, input: { responseDueOn: string; reason: string }) { return apiRequest(`/inspection-acts/${actId}/administration/deadline`, { method: 'PATCH', body: JSON.stringify(input) }); }
+export function addActCompanyResponse(actId: string, input: { receivedOn: string; details?: string; committedCorrectionOn?: string; contactName?: string; contactEmail?: string; file?: File }) {
+  const body = new FormData(); body.append('receivedOn', input.receivedOn);
+  if (input.details) body.append('details', input.details); if (input.committedCorrectionOn) body.append('committedCorrectionOn', input.committedCorrectionOn);
+  if (input.contactName) body.append('contactName', input.contactName); if (input.contactEmail) body.append('contactEmail', input.contactEmail); if (input.file) body.append('file', input.file);
+  return apiRequest(`/inspection-acts/${actId}/administration/responses`, { method: 'POST', body });
+}
+export function actCompanyResponseContentUrl(responseId: string) { return `${API_BASE}/act-company-responses/${responseId}/content`; }
+export function listActAdministrationCalendar(from?: string, to?: string) { const q=new URLSearchParams(); if(from)q.set('from',from); if(to)q.set('to',to); return apiRequest<{from:string;to:string;data:Array<{type:'RESPONSE_DUE'|'COMMITMENT_DUE';date:string;actId:string;actCode:string;areaName:string|null;companyName:string|null;state:ActAdministrationState}>}>(`/act-administration/calendar${q.size?`?${q}`:''}`); }
+

From d2ae9f9bd460a58e7236b42f1a77c6ffc9e58bb4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:42:35 -0300
Subject: [PATCH 132/224] F4: remove Survey entities from ORM registry

---
 api-v3/src/database/entities/index.ts | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/api-v3/src/database/entities/index.ts b/api-v3/src/database/entities/index.ts
index cd1cff6..8aa0bea 100644
--- a/api-v3/src/database/entities/index.ts
+++ b/api-v3/src/database/entities/index.ts
@@ -21,11 +21,6 @@ export { AssetTypeParentRule } from './asset-type-parent-rule.entity';
 export { AssetType, AssetTypeOperationalRole } from './asset-type.entity';
 export { AssetGeometry, AssetGeometrySource, AssetGeometryType } from './asset-geometry.entity';
 export { AssetMedia, AssetMediaKind, AssetMediaSource } from './asset-media.entity';
-export { SurveyCampaign, SurveyCampaignStatus } from './survey-campaign.entity';
-export { SurveyCampaignTarget, SurveyTargetStatus } from './survey-campaign-target.entity';
-export { SurveyReportOutcome, SurveyReportStatus, SurveyTargetReport } from './survey-target-report.entity';
-export { SurveyTargetReportMedia } from './survey-target-report-media.entity';
-export { SurveyReportVersionEvent, SurveyTargetReportVersion } from './survey-target-report-version.entity';
 export { InspectionVisit, InspectionVisitStatus } from './inspection-visit.entity';
 export { InspectionVisitAsset, InspectionVisitAssetPlanningSource } from './inspection-visit-asset.entity';
 export { InspectionVisitMember } from './inspection-visit-member.entity';
@@ -109,11 +104,6 @@ import { AreaLegalRightOrganization } from './area-legal-right-organization.enti
 import { AssetGeometry } from './asset-geometry.entity';
 import { AssetVersion } from './asset-version.entity';
 import { AssetMedia } from './asset-media.entity';
-import { SurveyCampaign } from './survey-campaign.entity';
-import { SurveyCampaignTarget } from './survey-campaign-target.entity';
-import { SurveyTargetReport } from './survey-target-report.entity';
-import { SurveyTargetReportMedia } from './survey-target-report-media.entity';
-import { SurveyTargetReportVersion } from './survey-target-report-version.entity';
 import { InspectionVisit } from './inspection-visit.entity';
 import { InspectionVisitAsset } from './inspection-visit-asset.entity';
 import { InspectionVisitMember } from './inspection-visit-member.entity';
@@ -166,11 +156,6 @@ export const PHASE_A_ENTITIES = [
   AssetGeometry,
   AssetVersion,
   AssetMedia,
-  SurveyCampaign,
-  SurveyCampaignTarget,
-  SurveyTargetReport,
-  SurveyTargetReportMedia,
-  SurveyTargetReportVersion,
   InspectionVisit,
   InspectionVisitAsset,
   InspectionVisitMember,

From 0aa4e06d17e6b1413de4c9b203d3744f91011b89 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:42:44 -0300
Subject: [PATCH 133/224] F4: remove Survey campaign entity

---
 .../entities/survey-campaign.entity.ts        | 51 -------------------
 1 file changed, 51 deletions(-)
 delete mode 100644 api-v3/src/database/entities/survey-campaign.entity.ts

diff --git a/api-v3/src/database/entities/survey-campaign.entity.ts b/api-v3/src/database/entities/survey-campaign.entity.ts
deleted file mode 100644
index a6c536d..0000000
--- a/api-v3/src/database/entities/survey-campaign.entity.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
-import { TimestampedEntity } from './timestamped.entity';
-
-export enum SurveyCampaignStatus {
-  DRAFT = 'DRAFT',
-  PLANNED = 'PLANNED',
-  IN_PROGRESS = 'IN_PROGRESS',
-  COMPLETED = 'COMPLETED',
-  CANCELLED = 'CANCELLED',
-}
-
-@Entity({ name: 'survey_campaigns' })
-@Index('uq_survey_campaigns_code', ['code'], { unique: true })
-@Index('idx_survey_campaigns_status', ['status'])
-@Index('idx_survey_campaigns_scope_asset_id', ['scopeAssetId'])
-@Index('idx_survey_campaigns_coordinator_user_id', ['coordinatorUserId'])
-@Index('idx_survey_campaigns_planned_dates', ['plannedStartAt', 'plannedEndAt'])
-export class SurveyCampaign extends TimestampedEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string;
-
-  @Column({ type: 'varchar', length: 80 })
-  code!: string;
-
-  @Column({ type: 'varchar', length: 200 })
-  name!: string;
-
-  @Column({ type: 'text', nullable: true })
-  description!: string | null;
-
-  @Column({ type: 'varchar', length: 24, default: SurveyCampaignStatus.DRAFT })
-  status!: SurveyCampaignStatus;
-
-  @Column({ name: 'planned_start_at', type: 'timestamptz', nullable: true })
-  plannedStartAt!: Date | null;
-
-  @Column({ name: 'planned_end_at', type: 'timestamptz', nullable: true })
-  plannedEndAt!: Date | null;
-
-  @Column({ name: 'scope_asset_id', type: 'uuid', nullable: true })
-  scopeAssetId!: string | null;
-
-  @Column({ name: 'coordinator_user_id', type: 'uuid', nullable: true })
-  coordinatorUserId!: string | null;
-
-  @Column({ name: 'created_by', type: 'uuid', nullable: true })
-  createdBy!: string | null;
-
-  @Column({ name: 'updated_by', type: 'uuid', nullable: true })
-  updatedBy!: string | null;
-}

From 0609b7faabf99aadebc604a56f63598c7eb42bfb Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:42:54 -0300
Subject: [PATCH 134/224] F4: remove Survey campaign target entity

---
 .../entities/survey-campaign-target.entity.ts | 44 -------------------
 1 file changed, 44 deletions(-)
 delete mode 100644 api-v3/src/database/entities/survey-campaign-target.entity.ts

diff --git a/api-v3/src/database/entities/survey-campaign-target.entity.ts b/api-v3/src/database/entities/survey-campaign-target.entity.ts
deleted file mode 100644
index f944fbb..0000000
--- a/api-v3/src/database/entities/survey-campaign-target.entity.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
-import { TimestampedEntity } from './timestamped.entity';
-
-export enum SurveyTargetStatus {
-  PENDING = 'PENDING',
-  IN_PROGRESS = 'IN_PROGRESS',
-  SUBMITTED = 'SUBMITTED',
-  COMPLETED = 'COMPLETED',
-  SKIPPED = 'SKIPPED',
-}
-
-@Entity({ name: 'survey_campaign_targets' })
-@Index('uq_survey_campaign_targets_campaign_asset', ['campaignId', 'assetId'], { unique: true })
-@Index('idx_survey_campaign_targets_campaign_status', ['campaignId', 'status'])
-@Index('idx_survey_campaign_targets_asset_id', ['assetId'])
-@Index('idx_survey_campaign_targets_assigned_user_id', ['assignedUserId'])
-export class SurveyCampaignTarget extends TimestampedEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string;
-
-  @Column({ name: 'campaign_id', type: 'uuid' })
-  campaignId!: string;
-
-  @Column({ name: 'asset_id', type: 'uuid' })
-  assetId!: string;
-
-  @Column({ name: 'assigned_user_id', type: 'uuid', nullable: true })
-  assignedUserId!: string | null;
-
-  @Column({ type: 'varchar', length: 24, default: SurveyTargetStatus.PENDING })
-  status!: SurveyTargetStatus;
-
-  @Column({ name: 'due_at', type: 'timestamptz', nullable: true })
-  dueAt!: Date | null;
-
-  @Column({ type: 'text', nullable: true })
-  instructions!: string | null;
-
-  @Column({ name: 'created_by', type: 'uuid', nullable: true })
-  createdBy!: string | null;
-
-  @Column({ name: 'updated_by', type: 'uuid', nullable: true })
-  updatedBy!: string | null;
-}

From b5b6942e3900648c71c99417ce863d690eb84a58 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:43:07 -0300
Subject: [PATCH 135/224] F4: remove Survey target report entity

---
 .../entities/survey-target-report.entity.ts   | 73 -------------------
 1 file changed, 73 deletions(-)
 delete mode 100644 api-v3/src/database/entities/survey-target-report.entity.ts

diff --git a/api-v3/src/database/entities/survey-target-report.entity.ts b/api-v3/src/database/entities/survey-target-report.entity.ts
deleted file mode 100644
index b835063..0000000
--- a/api-v3/src/database/entities/survey-target-report.entity.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
-import { TimestampedEntity } from './timestamped.entity';
-
-export enum SurveyReportOutcome {
-  CONFIRMED = 'CONFIRMED',
-  CHANGES_RECORDED = 'CHANGES_RECORDED',
-  NOT_LOCATED = 'NOT_LOCATED',
-}
-
-export enum SurveyReportStatus {
-  DRAFT = 'DRAFT',
-  SUBMITTED = 'SUBMITTED',
-  APPROVED = 'APPROVED',
-  REJECTED = 'REJECTED',
-}
-
-@Entity({ name: 'survey_target_reports' })
-@Index('uq_survey_target_reports_target_id', ['targetId'], { unique: true })
-@Index('idx_survey_target_reports_status', ['status'])
-@Index('idx_survey_target_reports_submitted_by', ['submittedBy'])
-@Index('idx_survey_target_reports_reviewed_by', ['reviewedBy'])
-export class SurveyTargetReport extends TimestampedEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string;
-
-  @Column({ name: 'target_id', type: 'uuid' })
-  targetId!: string;
-
-  @Column({ type: 'varchar', length: 32, nullable: true })
-  outcome!: SurveyReportOutcome | null;
-
-  @Column({ type: 'varchar', length: 24, default: SurveyReportStatus.DRAFT })
-  status!: SurveyReportStatus;
-
-  @Column({ name: 'observed_at', type: 'timestamptz', nullable: true })
-  observedAt!: Date | null;
-
-  @Column({ type: 'numeric', precision: 9, scale: 6, nullable: true })
-  latitude!: string | null;
-
-  @Column({ type: 'numeric', precision: 9, scale: 6, nullable: true })
-  longitude!: string | null;
-
-  @Column({ name: 'accuracy_m', type: 'numeric', precision: 12, scale: 3, nullable: true })
-  accuracyM!: string | null;
-
-  @Column({ type: 'text', nullable: true })
-  notes!: string | null;
-
-  @Column({ name: 'asset_version_at_submission', type: 'integer', nullable: true })
-  assetVersionAtSubmission!: number | null;
-
-  @Column({ name: 'submitted_at', type: 'timestamptz', nullable: true })
-  submittedAt!: Date | null;
-
-  @Column({ name: 'submitted_by', type: 'uuid', nullable: true })
-  submittedBy!: string | null;
-
-  @Column({ name: 'reviewed_at', type: 'timestamptz', nullable: true })
-  reviewedAt!: Date | null;
-
-  @Column({ name: 'reviewed_by', type: 'uuid', nullable: true })
-  reviewedBy!: string | null;
-
-  @Column({ name: 'review_notes', type: 'text', nullable: true })
-  reviewNotes!: string | null;
-
-  @Column({ name: 'created_by', type: 'uuid', nullable: true })
-  createdBy!: string | null;
-
-  @Column({ name: 'updated_by', type: 'uuid', nullable: true })
-  updatedBy!: string | null;
-}

From 27f52a05c8e8950bb8d6beaf64577d251073fbfa Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:43:21 -0300
Subject: [PATCH 136/224] F4: remove Survey report version entity

---
 .../survey-target-report-version.entity.ts    | 36 -------------------
 1 file changed, 36 deletions(-)
 delete mode 100644 api-v3/src/database/entities/survey-target-report-version.entity.ts

diff --git a/api-v3/src/database/entities/survey-target-report-version.entity.ts b/api-v3/src/database/entities/survey-target-report-version.entity.ts
deleted file mode 100644
index b32a790..0000000
--- a/api-v3/src/database/entities/survey-target-report-version.entity.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
-
-export enum SurveyReportVersionEvent {
-  SUBMITTED = 'SUBMITTED',
-  APPROVED = 'APPROVED',
-  REJECTED = 'REJECTED',
-}
-
-@Entity({ name: 'survey_target_report_versions' })
-@Index('uq_survey_target_report_versions_number', ['reportId', 'versionNumber'], { unique: true })
-@Index('idx_survey_target_report_versions_created_at', ['createdAt'])
-export class SurveyTargetReportVersion {
-  @PrimaryGeneratedColumn('uuid')
-  id!: string;
-
-  @Column({ name: 'report_id', type: 'uuid' })
-  reportId!: string;
-
-  @Column({ name: 'version_number', type: 'integer' })
-  versionNumber!: number;
-
-  @Column({ type: 'varchar', length: 24 })
-  event!: SurveyReportVersionEvent;
-
-  @Column({ type: 'jsonb' })
-  snapshot!: Record<string, unknown>;
-
-  @Column({ name: 'actor_user_id', type: 'uuid', nullable: true })
-  actorUserId!: string | null;
-
-  @Column({ name: 'actor_username', type: 'varchar', length: 80, nullable: true })
-  actorUsername!: string | null;
-
-  @Column({ name: 'created_at', type: 'timestamptz', default: () => 'CURRENT_TIMESTAMP' })
-  createdAt!: Date;
-}

From cc8c5d939299415056956160e72b9bad1a0c58f5 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:43:31 -0300
Subject: [PATCH 137/224] F4: remove Survey report media entity

---
 .../survey-target-report-media.entity.ts      | 19 -------------------
 1 file changed, 19 deletions(-)
 delete mode 100644 api-v3/src/database/entities/survey-target-report-media.entity.ts

diff --git a/api-v3/src/database/entities/survey-target-report-media.entity.ts b/api-v3/src/database/entities/survey-target-report-media.entity.ts
deleted file mode 100644
index 66dfadb..0000000
--- a/api-v3/src/database/entities/survey-target-report-media.entity.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { Column, Entity, Index, PrimaryColumn } from 'typeorm';
-import { TimestampedEntity } from './timestamped.entity';
-
-@Entity({ name: 'survey_target_report_media' })
-@Index('idx_survey_target_report_media_media_id', ['mediaId'])
-@Index('idx_survey_target_report_media_included', ['reportId', 'included'])
-export class SurveyTargetReportMedia extends TimestampedEntity {
-  @PrimaryColumn({ name: 'report_id', type: 'uuid' })
-  reportId!: string;
-
-  @PrimaryColumn({ name: 'media_id', type: 'uuid' })
-  mediaId!: string;
-
-  @Column({ type: 'boolean', default: true })
-  included!: boolean;
-
-  @Column({ name: 'added_by', type: 'uuid', nullable: true })
-  addedBy!: string | null;
-}

From e3b24cba3df294bfcdf71b7abe3a38ae538ac43e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 06:44:06 -0300
Subject: [PATCH 138/224] F4: remove obsolete Survey subsystem schema and
 permissions

---
 ...790000300000-f4-remove-survey-subsystem.ts | 220 ++++++++++++++++++
 1 file changed, 220 insertions(+)
 create mode 100644 api-v3/src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts

diff --git a/api-v3/src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts b/api-v3/src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts
new file mode 100644
index 0000000..dad8d8e
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts
@@ -0,0 +1,220 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+const surveyPermissions = [
+  'surveys.read',
+  'surveys.manage',
+  'surveys.assign',
+  'surveys.execute',
+  'surveys.read_reports',
+  'surveys.capture',
+  'surveys.review',
+] as const;
+
+const rolePermissionValues = `
+  ('admin', 'surveys.read'),
+  ('admin', 'surveys.manage'),
+  ('admin', 'surveys.assign'),
+  ('admin', 'surveys.execute'),
+  ('admin', 'surveys.read_reports'),
+  ('admin', 'surveys.capture'),
+  ('admin', 'surveys.review'),
+  ('director', 'surveys.read'),
+  ('director', 'surveys.read_reports'),
+  ('director', 'surveys.review'),
+  ('supervisor', 'surveys.read'),
+  ('supervisor', 'surveys.manage'),
+  ('supervisor', 'surveys.assign'),
+  ('supervisor', 'surveys.execute'),
+  ('supervisor', 'surveys.read_reports'),
+  ('supervisor', 'surveys.capture'),
+  ('supervisor', 'surveys.review'),
+  ('inspector', 'surveys.read'),
+  ('inspector', 'surveys.execute'),
+  ('inspector', 'surveys.read_reports'),
+  ('inspector', 'surveys.capture'),
+  ('auditor', 'surveys.read'),
+  ('auditor', 'surveys.read_reports')
+`;
+
+function quoteIdentifier(identifier: string): string {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+export class F4RemoveSurveySubsystem1790000300000 implements MigrationInterface {
+  name = 'F4RemoveSurveySubsystem1790000300000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM role_permissions
+      WHERE permission_id IN (
+        SELECT id FROM permissions WHERE code = ANY($1::varchar[])
+      )
+    `, [surveyPermissions]);
+    await queryRunner.query(
+      `DELETE FROM permissions WHERE code = ANY($1::varchar[])`,
+      [surveyPermissions],
+    );
+
+    // Deliberadamente sin CASCADE: una dependencia externa debe detener la migración.
+    await queryRunner.query(`DROP TABLE IF EXISTS survey_target_report_versions`);
+    await queryRunner.query(`DROP TABLE IF EXISTS survey_target_report_media`);
+    await queryRunner.query(`DROP TABLE IF EXISTS survey_target_reports`);
+    await queryRunner.query(`DROP TABLE IF EXISTS survey_campaign_targets`);
+    await queryRunner.query(`DROP TABLE IF EXISTS survey_campaigns`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS survey_campaigns (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        code varchar(80) NOT NULL UNIQUE,
+        name varchar(200) NOT NULL,
+        description text,
+        status varchar(24) NOT NULL DEFAULT 'DRAFT',
+        planned_start_at timestamptz,
+        planned_end_at timestamptz,
+        scope_asset_id uuid REFERENCES assets(id) ON DELETE RESTRICT,
+        coordinator_user_id uuid REFERENCES users(id) ON DELETE SET NULL,
+        created_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        updated_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT chk_survey_campaigns_status CHECK (
+          status IN ('DRAFT','PLANNED','IN_PROGRESS','COMPLETED','CANCELLED')
+        ),
+        CONSTRAINT chk_survey_campaigns_dates CHECK (
+          planned_start_at IS NULL OR planned_end_at IS NULL OR planned_end_at >= planned_start_at
+        )
+      )
+    `);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_campaigns_status ON survey_campaigns(status)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_campaigns_scope_asset_id ON survey_campaigns(scope_asset_id)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_campaigns_coordinator_user_id ON survey_campaigns(coordinator_user_id)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_campaigns_planned_dates ON survey_campaigns(planned_start_at,planned_end_at)`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS survey_campaign_targets (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        campaign_id uuid NOT NULL REFERENCES survey_campaigns(id) ON DELETE RESTRICT,
+        asset_id uuid NOT NULL REFERENCES assets(id) ON DELETE RESTRICT,
+        assigned_user_id uuid REFERENCES users(id) ON DELETE SET NULL,
+        status varchar(24) NOT NULL DEFAULT 'PENDING',
+        due_at timestamptz,
+        instructions text,
+        created_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        updated_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT uq_survey_campaign_targets_campaign_asset UNIQUE(campaign_id,asset_id),
+        CONSTRAINT chk_survey_campaign_targets_status CHECK (
+          status IN ('PENDING','IN_PROGRESS','SUBMITTED','COMPLETED','SKIPPED')
+        )
+      )
+    `);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_campaign_targets_campaign_status ON survey_campaign_targets(campaign_id,status)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_campaign_targets_asset_id ON survey_campaign_targets(asset_id)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_campaign_targets_assigned_user_id ON survey_campaign_targets(assigned_user_id)`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS survey_target_reports (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        target_id uuid NOT NULL UNIQUE REFERENCES survey_campaign_targets(id) ON DELETE RESTRICT,
+        outcome varchar(32),
+        status varchar(24) NOT NULL DEFAULT 'DRAFT',
+        observed_at timestamptz,
+        latitude numeric(9,6),
+        longitude numeric(9,6),
+        accuracy_m numeric(12,3),
+        notes text,
+        asset_version_at_submission integer,
+        submitted_at timestamptz,
+        submitted_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        reviewed_at timestamptz,
+        reviewed_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        review_notes text,
+        created_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        updated_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT chk_survey_target_reports_outcome CHECK (
+          outcome IS NULL OR outcome IN ('CONFIRMED','CHANGES_RECORDED','NOT_LOCATED')
+        ),
+        CONSTRAINT chk_survey_target_reports_status CHECK (
+          status IN ('DRAFT','SUBMITTED','APPROVED','REJECTED')
+        ),
+        CONSTRAINT chk_survey_target_reports_coordinates CHECK (
+          (latitude IS NULL AND longitude IS NULL)
+          OR (latitude IS NOT NULL AND longitude IS NOT NULL
+            AND latitude BETWEEN -90 AND 90 AND longitude BETWEEN -180 AND 180)
+        ),
+        CONSTRAINT chk_survey_target_reports_accuracy CHECK (
+          accuracy_m IS NULL OR (accuracy_m >= 0 AND latitude IS NOT NULL AND longitude IS NOT NULL)
+        )
+      )
+    `);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_target_reports_status ON survey_target_reports(status)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_target_reports_submitted_by ON survey_target_reports(submitted_by)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_target_reports_reviewed_by ON survey_target_reports(reviewed_by)`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS survey_target_report_media (
+        report_id uuid NOT NULL REFERENCES survey_target_reports(id) ON DELETE RESTRICT,
+        media_id uuid NOT NULL REFERENCES asset_media(id) ON DELETE RESTRICT,
+        included boolean NOT NULL DEFAULT true,
+        added_by uuid REFERENCES users(id) ON DELETE SET NULL,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY(report_id,media_id)
+      )
+    `);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_target_report_media_media_id ON survey_target_report_media(media_id)`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_target_report_media_included ON survey_target_report_media(report_id,included)`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS survey_target_report_versions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        report_id uuid NOT NULL REFERENCES survey_target_reports(id) ON DELETE RESTRICT,
+        version_number integer NOT NULL,
+        event varchar(24) NOT NULL,
+        snapshot jsonb NOT NULL,
+        actor_user_id uuid REFERENCES users(id) ON DELETE SET NULL,
+        actor_username varchar(80),
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT uq_survey_target_report_versions_number UNIQUE(report_id,version_number),
+        CONSTRAINT chk_survey_target_report_versions_event CHECK (
+          event IN ('SUBMITTED','APPROVED','REJECTED')
+        )
+      )
+    `);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_survey_target_report_versions_created_at ON survey_target_report_versions(created_at)`);
+
+    await queryRunner.query(`
+      INSERT INTO permissions(code,description) VALUES
+        ('surveys.read','Consultar planificación de relevamientos'),
+        ('surveys.manage','Crear y actualizar campañas de relevamiento'),
+        ('surveys.assign','Asignar objetivos de relevamiento'),
+        ('surveys.execute','Actualizar el avance de objetivos asignados'),
+        ('surveys.read_reports','Consultar capturas y versiones de relevamientos'),
+        ('surveys.capture','Capturar y enviar relevamientos de campo'),
+        ('surveys.review','Aprobar o rechazar relevamientos enviados')
+      ON CONFLICT(code) DO UPDATE SET description=EXCLUDED.description
+    `);
+    await queryRunner.query(`
+      WITH mapping(role_code,permission_code) AS (VALUES ${rolePermissionValues})
+      INSERT INTO role_permissions(role_id,permission_id)
+      SELECT role.id,permission.id
+      FROM mapping
+      JOIN roles role ON role.code=mapping.role_code
+      JOIN permissions permission ON permission.code=mapping.permission_code
+      ON CONFLICT(role_id,permission_id) DO NOTHING
+    `);
+
+    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 survey_campaigns,survey_campaign_targets,survey_target_reports,survey_target_report_media TO ${applicationRole}`);
+    await queryRunner.query(`GRANT SELECT,INSERT ON TABLE survey_target_report_versions TO ${applicationRole}`);
+    await queryRunner.query(`REVOKE DELETE ON TABLE survey_campaigns,survey_campaign_targets,survey_target_reports,survey_target_report_media,survey_target_report_versions FROM ${applicationRole}`);
+    await queryRunner.query(`REVOKE UPDATE ON TABLE survey_target_report_versions FROM ${applicationRole}`);
+  }
+}

From a4a57d31097b5634ffb15eb296c2cd8b10f17443 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:05:23 -0300
Subject: [PATCH 139/224] chore(web): remove legacy survey redirects

---
 web-v2/src/app/App.tsx | 2 --
 1 file changed, 2 deletions(-)

diff --git a/web-v2/src/app/App.tsx b/web-v2/src/app/App.tsx
index c38e77d..8b62df0 100644
--- a/web-v2/src/app/App.tsx
+++ b/web-v2/src/app/App.tsx
@@ -58,8 +58,6 @@ export function App() {
         <Route element={<PermissionRoute permission="asset_imports.read" />}><Route path="/importaciones" element={<AssetImportsPage />} /></Route>
         <Route element={<PermissionRoute permission="assets.create" />}><Route path="/inventarios/nuevo" element={<InventoryCreatePage />} /><Route path="/activos/nuevo" element={<Navigate to="/inventarios/nuevo" replace />} /></Route>
         <Route path="/planificacion" element={<Navigate to="/inspecciones?status=PLANNED" replace />} />
-        <Route path="/relevamiento" element={<Navigate to="/inventarios" replace />} />
-        <Route path="/relevamiento/*" element={<Navigate to="/inventarios" replace />} />
         <Route element={<PermissionRoute permission="inspections.read" />}>
           <Route path="/inspecciones" element={<InspectionVisitsPage />} />
           <Route path="/inspecciones/:id" element={<InspectionVisitEditorF4Page />} />

From 0718414fdb2836a04f7a8ade6b1a6d5b44000522 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:10:53 -0300
Subject: [PATCH 140/224] refactor(api): remove legacy director report fields

---
 .../entities/inspection-report.entity.ts      | 26 -------------------
 1 file changed, 26 deletions(-)

diff --git a/api-v3/src/database/entities/inspection-report.entity.ts b/api-v3/src/database/entities/inspection-report.entity.ts
index 7742475..4fba6b4 100644
--- a/api-v3/src/database/entities/inspection-report.entity.ts
+++ b/api-v3/src/database/entities/inspection-report.entity.ts
@@ -20,13 +20,6 @@ export enum InspectionReportWordStatus {
   FAILED = 'FAILED',
 }
 
-/** @deprecated El circuito Director/aprobación/firma se retira en F4. */
-export enum InspectionReportReviewStatus {
-  PENDING_REVIEW = 'PENDING_REVIEW',
-  APPROVED = 'APPROVED',
-  SIGNED = 'SIGNED',
-}
-
 @Entity({ name: 'inspection_reports' })
 @Index('idx_inspection_reports_visit_id', ['visitId'])
 @Index('uq_inspection_reports_act', ['actId'], { unique: true })
@@ -111,28 +104,9 @@ export class InspectionReport extends TimestampedEntity {
   @Column({ name: 'word_error', type: 'varchar', length: 500, nullable: true })
   wordError!: string | null;
 
-  // Campos legacy del circuito Director, conservados sólo hasta completar la migración F4.
-  @Column({ name: 'review_status', type: 'varchar', length: 32, default: InspectionReportReviewStatus.PENDING_REVIEW })
-  reviewStatus!: InspectionReportReviewStatus;
-
   @Column({ name: 'current_revision_number', type: 'integer', default: 0 })
   currentRevisionNumber!: number;
 
-  @Column({ name: 'approved_revision_id', type: 'uuid', nullable: true })
-  approvedRevisionId!: string | null;
-
-  @Column({ name: 'approved_by', type: 'uuid', nullable: true })
-  approvedBy!: string | null;
-
-  @Column({ name: 'approved_at', type: 'timestamptz', nullable: true })
-  approvedAt!: Date | null;
-
-  @Column({ name: 'review_note', type: 'varchar', length: 1000, nullable: true })
-  reviewNote!: string | null;
-
-  @Column({ name: 'signed_at', type: 'timestamptz', nullable: true })
-  signedAt!: Date | null;
-
   @Column({ type: 'varchar', length: 220 })
   title!: string;
 

From 2826960d71fb4d531d2f5af9c251c48b26361791 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:11:12 -0300
Subject: [PATCH 141/224] db(f4): drop legacy director report workflow

---
 ...400000-f4-remove-director-report-legacy.ts | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts

diff --git a/api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts b/api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts
new file mode 100644
index 0000000..da4f54f
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts
@@ -0,0 +1,42 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Retira definitivamente el circuito legacy Director -> revisión -> aprobación -> firma.
+ *
+ * current_revision_number se conserva porque pertenece al versionado útil del INF y no
+ * al circuito de aprobación retirado.
+ */
+export class F4RemoveDirectorReportLegacy1790000400000 implements MigrationInterface {
+  name = 'F4RemoveDirectorReportLegacy1790000400000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Las entregas al Director pertenecían al flujo retirado y no deben seguir
+    // apareciendo como pendientes/reintentables en F4.
+    await queryRunner.query(`
+      DELETE FROM inspection_document_deliveries
+      WHERE recipient_kind = 'DIRECTOR'
+    `);
+
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS approved_revision_id`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS approved_by`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS approved_at`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS review_note`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS signed_at`);
+    await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS review_status`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // El rollback reconstruye la forma del esquema, pero no recrea entregas Director
+    // ni datos de aprobación eliminados. El backup PRE-F4 es la fuente de recuperación
+    // si alguna vez fuera necesario volver a ese circuito.
+    await queryRunner.query(`
+      ALTER TABLE inspection_reports
+      ADD COLUMN IF NOT EXISTS review_status varchar(32) NOT NULL DEFAULT 'PENDING_REVIEW'
+    `);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS approved_revision_id uuid`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS approved_by uuid`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS approved_at timestamptz`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS review_note varchar(1000)`);
+    await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS signed_at timestamptz`);
+  }
+}

From d08162fca81447ab51fb388e00b7740715b64ef8 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:32:39 -0300
Subject: [PATCH 142/224] fix(f4): restrict SMTP administration to system admin

---
 .../document-delivery.controller.ts            | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/api-v3/src/inspection-reports/document-delivery.controller.ts b/api-v3/src/inspection-reports/document-delivery.controller.ts
index 5fe49ca..1724473 100644
--- a/api-v3/src/inspection-reports/document-delivery.controller.ts
+++ b/api-v3/src/inspection-reports/document-delivery.controller.ts
@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Put, Req } from '@nestjs/common';
+import { Body, Controller, ForbiddenException, Get, Param, ParseUUIDPipe, Patch, Post, Put, Req } from '@nestjs/common';
 import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
 import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
@@ -37,7 +37,8 @@ export class DocumentDeliveryController {
 
   @Get('smtp')
   @RequirePermissions('document_delivery.manage')
-  smtpSettings() {
+  smtpSettings(@CurrentAuth() principal: AuthPrincipal) {
+    this.assertSystemAdmin(principal);
     return this.smtp.publicSettings();
   }
 
@@ -48,6 +49,7 @@ export class DocumentDeliveryController {
     @CurrentAuth() principal: AuthPrincipal,
     @Req() request: RequestWithContext,
   ) {
+    this.assertSystemAdmin(principal);
     const before = await this.smtp.publicSettings();
     const after = await this.smtp.saveSettings(dto, principal.userId);
     await this.audit.record({
@@ -57,7 +59,7 @@ export class DocumentDeliveryController {
       entityId: 'singleton',
       beforeData: before as Record<string, unknown>,
       afterData: after as Record<string, unknown>,
-      metadata: { passwordNeverReturned: true },
+      metadata: { passwordNeverReturned: true, restrictedToRole: 'admin' },
     });
     return after;
   }
@@ -69,6 +71,7 @@ export class DocumentDeliveryController {
     @CurrentAuth() principal: AuthPrincipal,
     @Req() request: RequestWithContext,
   ) {
+    this.assertSystemAdmin(principal);
     const sent = await this.smtp.send({
       to: dto.email,
       subject: 'DH Inspección · Prueba SMTP',
@@ -85,6 +88,7 @@ export class DocumentDeliveryController {
       entityType: 'system_smtp_settings',
       entityId: 'singleton',
       afterData: { recipient: dto.email, messageId: sent.messageId },
+      metadata: { restrictedToRole: 'admin' },
     });
     return { ok: true, recipient: dto.email, messageId: sent.messageId };
   }
@@ -113,4 +117,12 @@ export class DocumentDeliveryController {
   ) {
     return this.delivery.retryPending(principal, request);
   }
+
+  private assertSystemAdmin(principal: AuthPrincipal): void {
+    if (principal.roles.includes('admin')) return;
+    throw new ForbiddenException({
+      code: 'SMTP_SUPERADMIN_REQUIRED',
+      message: 'La configuración SMTP está reservada al Superadmin del sistema',
+    });
+  }
 }

From bd767b7e32581de53ffadee9f770f4f14e865d87 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:35:08 -0300
Subject: [PATCH 143/224] fix(f4): hide SMTP controls outside system admin

---
 web-v2/src/pages/DocumentDeliveryPage.tsx | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/web-v2/src/pages/DocumentDeliveryPage.tsx b/web-v2/src/pages/DocumentDeliveryPage.tsx
index 9c26fe9..275a41c 100644
--- a/web-v2/src/pages/DocumentDeliveryPage.tsx
+++ b/web-v2/src/pages/DocumentDeliveryPage.tsx
@@ -41,8 +41,9 @@ function defaultPort(mode: SmtpSecurityMode): number {
 }
 
 export function DocumentDeliveryPage() {
-  const { hasPermission } = useAuth();
+  const { hasPermission, user } = useAuth();
   const canManage = hasPermission('document_delivery.manage');
+  const canSmtpAdmin = Boolean(user?.roles.includes('admin'));
   const [settings, setSettings] = useState<DocumentDeliverySettingsF4 | null>(null);
   const [smtp, setSmtp] = useState<PublicSmtpSettings | null>(null);
   const [items, setItems] = useState<DocumentDeliveryItemF4[]>([]);
@@ -79,7 +80,7 @@ export function DocumentDeliveryPage() {
     const [currentSettings, outbox, smtpSettings] = await Promise.all([
       getDocumentDeliverySettingsF4(),
       listDocumentDeliveriesF4(),
-      canManage ? getSmtpSettings() : Promise.resolve(null),
+      canSmtpAdmin ? getSmtpSettings() : Promise.resolve(null),
     ]);
     setSettings(currentSettings);
     setOfficeEmail(currentSettings.officeEmail ?? '');
@@ -89,7 +90,7 @@ export function DocumentDeliveryPage() {
 
   useEffect(() => {
     load().catch((requestError) => setError(errorMessage(requestError))).finally(() => setLoading(false));
-  }, [canManage]);
+  }, [canSmtpAdmin]);
 
   const saveOffice = async (event: FormEvent) => {
     event.preventDefault();
@@ -104,7 +105,7 @@ export function DocumentDeliveryPage() {
 
   const saveSmtp = async (event: FormEvent) => {
     event.preventDefault();
-    if (!host.trim() || !fromName.trim() || !fromEmail.trim()) return;
+    if (!canSmtpAdmin || !host.trim() || !fromName.trim() || !fromEmail.trim()) return;
     setSaving(true); setError(''); setSuccess('');
     try {
       const input: Parameters<typeof saveSmtpSettings>[0] = {
@@ -129,7 +130,7 @@ export function DocumentDeliveryPage() {
 
   const sendTest = async (event: FormEvent) => {
     event.preventDefault();
-    if (!testEmail.trim()) return;
+    if (!canSmtpAdmin || !testEmail.trim()) return;
     setSaving(true); setError(''); setSuccess('');
     try {
       const result = await testSmtpSettings(testEmail.trim());
@@ -151,7 +152,7 @@ export function DocumentDeliveryPage() {
   if (loading) return <LoadingBlock label="Cargando entrega documental…" />;
 
   return <section className="narrow-section">
-    <div className="page-heading"><div><span className="eyebrow">SUPERADMIN · CORREO</span><h1>Entrega documental</h1><p>Configuración institucional de SMTP, destinatarios y trazabilidad de los envíos automáticos.</p></div>{canManage && <button className="button secondary" onClick={retryAll} disabled={saving}><Icon name="history" />Reintentar pendientes</button>}</div>
+    <div className="page-heading"><div><span className="eyebrow">ENTREGA DOCUMENTAL</span><h1>Correo y envíos</h1><p>Destinatarios institucionales, trazabilidad de envíos y configuración técnica de correo reservada al Superadmin.</p></div>{canManage && <button className="button secondary" onClick={retryAll} disabled={saving}><Icon name="history" />Reintentar pendientes</button>}</div>
     {error && <Alert>{error}</Alert>}{success && <Alert type="success">{success}</Alert>}
 
     <form className="panel form-panel" onSubmit={saveOffice}>
@@ -163,9 +164,9 @@ export function DocumentDeliveryPage() {
       </div>
     </form>
 
-    {canManage && <form className="panel form-panel" onSubmit={saveSmtp}>
+    {canSmtpAdmin && <form className="panel form-panel" onSubmit={saveSmtp}>
       <div className="form-section">
-        <div><span className="eyebrow">SALIDA DE EMAIL</span><h2>Servidor SMTP</h2><p className="section-copy">La contraseña se cifra en el servidor con AES-256-GCM. Al volver a esta pantalla sólo se informa si existe una clave guardada; nunca se devuelve su contenido.</p></div>
+        <div><span className="eyebrow">SUPERADMIN · SALIDA DE EMAIL</span><h2>Servidor SMTP</h2><p className="section-copy">La contraseña se cifra en el servidor con AES-256-GCM. Al volver a esta pantalla sólo se informa si existe una clave guardada; nunca se devuelve su contenido.</p></div>
         {smtp?.source === 'ENVIRONMENT' && <Alert type="info">Actualmente se está usando la configuración del servidor. Al guardar este formulario, la configuración de base de datos administrable pasará a tener prioridad.</Alert>}
         <div className="form-grid">
           <label className="field"><span>Host SMTP</span><input value={host} onChange={(event) => setHost(event.target.value)} required maxLength={255} placeholder="smtp.ejemplo.com" /></label>
@@ -182,7 +183,9 @@ export function DocumentDeliveryPage() {
       </div>
     </form>}
 
-    {canManage && <form className="panel form-panel" onSubmit={sendTest}><div className="form-section"><div><h2>Probar configuración</h2><p className="section-copy">Envía un correo real con un archivo de prueba usando exactamente la configuración activa.</p></div><div className="form-grid"><label className="field"><span>Email de prueba</span><input type="email" value={testEmail} onChange={(event) => setTestEmail(event.target.value)} required placeholder="tu@email.com" /></label></div><div className="form-actions"><button className="button secondary" disabled={saving || !testEmail.trim()}>Enviar prueba</button></div></div></form>}
+    {canSmtpAdmin && <form className="panel form-panel" onSubmit={sendTest}><div className="form-section"><div><h2>Probar configuración</h2><p className="section-copy">Envía un correo real con un archivo de prueba usando exactamente la configuración activa.</p></div><div className="form-grid"><label className="field"><span>Email de prueba</span><input type="email" value={testEmail} onChange={(event) => setTestEmail(event.target.value)} required placeholder="tu@email.com" /></label></div><div className="form-actions"><button className="button secondary" disabled={saving || !testEmail.trim()}>Enviar prueba</button></div></div></form>}
+
+    {!canSmtpAdmin && <div className="temporal-notice"><Icon name="lock" /><p><strong>SMTP reservado al Superadmin.</strong> Los usuarios operativos pueden consultar la trazabilidad y, según permisos, gestionar entregas, pero no ver ni modificar credenciales de correo.</p></div>}
 
     <article className="panel">
       <div className="panel-heading"><div><span className="eyebrow">TRAZABILIDAD</span><h2>Últimas entregas</h2><p className="section-copy">Actas PDF a Empresa/Oficina/Inspector e INF Word editable al Inspector responsable.</p></div><span className="count-pill">{items.length}</span></div>

From 3f0a1e544155ded7d6c124303c7f58e1fc99dc8c Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:39:38 -0300
Subject: [PATCH 144/224] refactor(f4): remove legacy inspection lifecycle and
 public title/end date

---
 .../inspection-visits.service.ts              | 211 +-----------------
 1 file changed, 3 insertions(+), 208 deletions(-)

diff --git a/api-v3/src/inspection-visits/inspection-visits.service.ts b/api-v3/src/inspection-visits/inspection-visits.service.ts
index 8bb29d6..b4208b7 100644
--- a/api-v3/src/inspection-visits/inspection-visits.service.ts
+++ b/api-v3/src/inspection-visits/inspection-visits.service.ts
@@ -1,7 +1,6 @@
 import {
   BadRequestException,
   ConflictException,
-  ForbiddenException,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
@@ -18,14 +17,11 @@ import {
   InspectionVisitAssetPlanningSource,
   InspectionVisitStatus,
 } from '../database/entities';
-import type { ChangeInspectionVisitStatusDto } from './dto/change-inspection-visit-status.dto';
-import type { CloseInspectionVisitDto } from './dto/close-inspection-visit.dto';
 import type { CreateInspectionVisitDto } from './dto/create-inspection-visit.dto';
 import type { ListInspectionVisitsQueryDto } from './dto/list-inspection-visits-query.dto';
 import type { ReplaceInspectionVisitAssetsDto } from './dto/replace-inspection-visit-assets.dto';
 import type { ReplaceInspectionVisitTeamDto } from './dto/replace-inspection-visit-team.dto';
 import type { UpdateInspectionVisitDto } from './dto/update-inspection-visit.dto';
-import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
 import { nextInspectionVisitCode } from './inspection-visit-code';
 
 export interface InspectionPerson {
@@ -91,7 +87,6 @@ export interface InspectionVisitChecklistSummary {
 export interface InspectionVisitListItem {
   id: string;
   code: string;
-  title: string;
   objective: string | null;
   status: InspectionVisitStatus;
   scopeAsset: InspectionAssetSummary | null;
@@ -99,7 +94,6 @@ export interface InspectionVisitListItem {
   operatorCompany: InspectionPlanningContextAsset | null;
   leadInspector: InspectionPerson | null;
   plannedStartAt: Date | null;
-  plannedEndAt: Date | null;
   actualStartedAt: Date | null;
   actualClosedAt: Date | null;
   instructions: string | null;
@@ -165,7 +159,7 @@ export class InspectionVisitsService {
     };
     if (query.search?.trim()) {
       const search = add(`%${query.search.trim()}%`);
-      conditions.push(`(visit.code ILIKE ${search} OR visit.title ILIKE ${search})`);
+      conditions.push(`visit.code ILIKE ${search}`);
     }
     if (query.status) conditions.push(`visit.status = ${add(query.status)}`);
     if (query.companyId) {
@@ -324,6 +318,8 @@ export class InspectionVisitsService {
         const code = await nextInspectionVisitCode(manager, plannedStartAt);
         const visit = manager.getRepository(InspectionVisit).create({
           code,
+          // Compatibilidad de persistencia temporal: estas dos columnas legacy se
+          // conservan hasta eliminar sus últimas lecturas históricas del repositorio.
           title: code,
           objective: null,
           status: InspectionVisitStatus.DRAFT,
@@ -715,209 +711,11 @@ export class InspectionVisitsService {
     });
   }
 
-  async changeStatus(
-    id: string,
-    dto: ChangeInspectionVisitStatusDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InspectionVisitView> {
-    return this.dataSource.transaction(async (manager) => {
-      const visit = await this.lockVisit(manager, id);
-      if (visit.status === dto.status) return this.loadView(manager, id);
-      const cancellation = dto.status === InspectionVisitStatus.CANCELLED;
-      const reversiblePlanning =
-        (visit.status === InspectionVisitStatus.DRAFT && dto.status === InspectionVisitStatus.PLANNED) ||
-        (visit.status === InspectionVisitStatus.PLANNED && dto.status === InspectionVisitStatus.DRAFT);
-      const cancellable = cancellation && [
-        InspectionVisitStatus.DRAFT,
-        InspectionVisitStatus.PLANNED,
-        InspectionVisitStatus.IN_PROGRESS,
-      ].includes(visit.status);
-      if (!reversiblePlanning && !cancellable) {
-        throw new ConflictException({
-          code: 'INSPECTION_VISIT_INVALID_TRANSITION',
-          message: 'La transición solicitada no está permitida en esta fase',
-        });
-      }
-      if (dto.status === InspectionVisitStatus.PLANNED) {
-        await this.validatePlan(manager, visit);
-      }
-      const reason = dto.reason?.trim() || null;
-      if (cancellation && (!reason || reason.length < 10)) {
-        throw new BadRequestException({
-          code: 'INSPECTION_CANCELLATION_REASON_REQUIRED',
-          message: 'Indicá un motivo de cancelación de al menos 10 caracteres',
-        });
-      }
-      const beforeStatus = visit.status;
-      visit.status = dto.status;
-      visit.cancellationReason = cancellation ? reason : null;
-      visit.updatedBy = principal.userId;
-      await manager.getRepository(InspectionVisit).save(visit);
-      const updated = await this.loadView(manager, id);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_VISIT_STATUS_CHANGED,
-        entityType: 'inspection_visit',
-        entityId: id,
-        beforeData: { status: beforeStatus },
-        afterData: { status: dto.status, cancellationReason: visit.cancellationReason },
-      }, manager);
-      return updated;
-    });
-  }
-
-  async start(
-    id: string,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InspectionVisitView> {
-    assertMobileInspector(principal);
-    return this.dataSource.transaction(async (manager) => {
-      const visit = await this.lockVisit(manager, id);
-      if (visit.status !== InspectionVisitStatus.PLANNED) {
-        throw new ConflictException({
-          code: 'INSPECTION_VISIT_NOT_PLANNED',
-          message: 'La visita debe estar planificada antes de iniciarse',
-        });
-      }
-      await this.validatePlan(manager, visit);
-      if (!principal.permissions.includes('inspections.manage')) {
-        const memberIds = await this.activeMemberIds(manager, id);
-        if (!memberIds.includes(principal.userId)) {
-          throw new ForbiddenException({
-            code: 'INSPECTION_VISIT_NOT_ASSIGNED',
-            message: 'La visita no está asignada al usuario actual',
-          });
-        }
-      }
-      visit.status = InspectionVisitStatus.IN_PROGRESS;
-      visit.actualStartedAt = new Date();
-      visit.updatedBy = principal.userId;
-      await manager.getRepository(InspectionVisit).save(visit);
-      const updated = await this.loadView(manager, id);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_VISIT_STARTED,
-        entityType: 'inspection_visit',
-        entityId: id,
-        beforeData: { status: InspectionVisitStatus.PLANNED, actualStartedAt: null },
-        afterData: {
-          status: InspectionVisitStatus.IN_PROGRESS,
-          actualStartedAt: visit.actualStartedAt,
-        },
-      }, manager);
-      return updated;
-    });
-  }
-
-
-  async close(
-    id: string,
-    dto: CloseInspectionVisitDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<InspectionVisitView> {
-    assertMobileInspector(principal);
-    return this.dataSource.transaction(async (manager) => {
-      const visit = await this.lockVisit(manager, id);
-      if (visit.status !== InspectionVisitStatus.IN_PROGRESS) {
-        throw new ConflictException({
-          code: 'INSPECTION_VISIT_NOT_IN_PROGRESS',
-          message: 'La inspección debe estar en curso para cerrarse',
-        });
-      }
-      if (!principal.permissions.includes('inspections.manage')) {
-        const memberIds = await this.activeMemberIds(manager, id);
-        if (!memberIds.includes(principal.userId)) {
-          throw new ForbiddenException({
-            code: 'INSPECTION_VISIT_NOT_ASSIGNED',
-            message: 'La inspección no está asignada al usuario actual',
-          });
-        }
-      }
-      const [acts] = (await manager.query(`
-        SELECT
-          COUNT(*) FILTER (WHERE act.status = 'DRAFT')::integer AS drafts,
-          COUNT(*) FILTER (
-            WHERE act.status = 'READY'
-              AND NOT EXISTS (
-                SELECT 1 FROM inspection_act_signatures signature
-                WHERE signature.act_id = act.id
-                  AND signature.signer_type = 'INSPECTOR'
-                  AND signature.status = 'SIGNED'
-              )
-          )::integer AS "readyWithoutInspector",
-          COUNT(*) FILTER (
-            WHERE act.status = 'READY'
-              AND NOT EXISTS (
-                SELECT 1 FROM inspection_act_signatures signature
-                WHERE signature.act_id = act.id
-                  AND signature.signer_type = 'COMPANY_RESPONSIBLE'
-              )
-          )::integer AS "pendingCompany"
-        FROM inspection_acts act
-        WHERE act.visit_id = $1
-          AND act.status <> 'CANCELLED'
-      `, [id])) as Array<{ drafts: number; readyWithoutInspector: number; pendingCompany: number }>;
-      if (Number(acts?.drafts ?? 0) > 0) {
-        throw new ConflictException({
-          code: 'INSPECTION_VISIT_DRAFT_ACTS_PENDING',
-          message: 'Prepará o cancelá las actas en borrador antes de cerrar la inspección',
-        });
-      }
-      if (Number(acts?.readyWithoutInspector ?? 0) > 0) {
-        throw new ConflictException({
-          code: 'INSPECTION_VISIT_INSPECTOR_SIGNATURE_PENDING',
-          message: 'Toda acta preparada debe tener firma de inspector antes de cerrar la inspección',
-        });
-      }
-      const serverClosedAt = new Date();
-      const clientClosedAt = new Date(dto.clientClosedAt);
-      if (visit.actualStartedAt && clientClosedAt.getTime() < visit.actualStartedAt.getTime()) {
-        throw new BadRequestException({
-          code: 'INSPECTION_VISIT_INVALID_CLOSE_TIME',
-          message: 'La fecha de cierre del dispositivo no puede ser anterior al inicio de la inspección',
-        });
-      }
-      if (clientClosedAt.getTime() > serverClosedAt.getTime() + 24 * 60 * 60 * 1000) {
-        throw new BadRequestException({
-          code: 'INSPECTION_VISIT_INVALID_DEVICE_TIME',
-          message: 'La fecha informada por el dispositivo no puede estar más de 24 horas en el futuro',
-        });
-      }
-      visit.status = InspectionVisitStatus.CLOSED;
-      visit.actualClosedAt = serverClosedAt;
-      visit.updatedBy = principal.userId;
-      await manager.getRepository(InspectionVisit).save(visit);
-      const updated = await this.loadView(manager, id);
-      await this.audit.record({
-        ...administrationAuditContext(principal, request),
-        action: AuditAction.INSPECTION_VISIT_STATUS_CHANGED,
-        entityType: 'inspection_visit',
-        entityId: id,
-        beforeData: { status: InspectionVisitStatus.IN_PROGRESS },
-        afterData: {
-          status: InspectionVisitStatus.CLOSED,
-          clientClosedAt: clientClosedAt.toISOString(),
-          serverClosedAt: serverClosedAt.toISOString(),
-          pendingCompanySignatures: Number(acts?.pendingCompany ?? 0),
-        },
-        metadata: {
-          closeSource: 'ANDROID',
-          actsMayCompleteCompanySignatureLater: true,
-        },
-      }, manager);
-      return updated;
-    });
-  }
-
   private visitSelect(where: string): string {
     return `
       SELECT
         visit.id,
         visit.code,
-        visit.title,
         visit.objective,
         visit.status,
         CASE WHEN scope.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
@@ -943,7 +741,6 @@ export class InspectionVisitsService {
           'lastName', lead.last_name
         ) END AS "leadInspector",
         visit.planned_start_at AS "plannedStartAt",
-        visit.planned_end_at AS "plannedEndAt",
         visit.actual_started_at AS "actualStartedAt",
         visit.actual_closed_at AS "actualClosedAt",
         visit.instructions,
@@ -1615,7 +1412,6 @@ export class InspectionVisitsService {
   private auditView(visit: InspectionVisitView): Record<string, unknown> {
     return {
       code: visit.code,
-      title: visit.title,
       objective: visit.objective,
       status: visit.status,
       scopeAssetId: visit.scopeAsset?.id ?? null,
@@ -1623,7 +1419,6 @@ export class InspectionVisitsService {
       operatorCompanyId: visit.operatorCompany?.id ?? null,
       leadInspectorUserId: visit.leadInspector?.id ?? null,
       plannedStartAt: visit.plannedStartAt,
-      plannedEndAt: visit.plannedEndAt,
       actualStartedAt: visit.actualStartedAt,
       actualClosedAt: visit.actualClosedAt,
       instructions: visit.instructions,

From ce0bbf1d94b64db0175ab220864df0af36b7b482 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:41:24 -0300
Subject: [PATCH 145/224] refactor(f4): align inspection wrapper with canonical
 contract

---
 .../f4-inspection-visits.service.ts           | 48 +++++++------------
 1 file changed, 17 insertions(+), 31 deletions(-)

diff --git a/api-v3/src/inspection-visits/f4-inspection-visits.service.ts b/api-v3/src/inspection-visits/f4-inspection-visits.service.ts
index 373f4f7..8987e5d 100644
--- a/api-v3/src/inspection-visits/f4-inspection-visits.service.ts
+++ b/api-v3/src/inspection-visits/f4-inspection-visits.service.ts
@@ -8,16 +8,11 @@ import type { InspectionVisitView } from './inspection-visits.service';
 import { InspectionVisitsService } from './inspection-visits.service';
 
 /**
- * Capa activa F4 sobre el servicio histórico de Inspecciones.
+ * Capa activa F4 sobre el servicio de Inspecciones.
  *
- * Mantiene las operaciones de planificación/equipo/Inventario ya probadas, pero
- * elimina de la salida funcional los conceptos retirados en F4:
- * - no existe un título de negocio independiente del código institucional;
- * - no existe fecha prevista de fin;
- * - el checklist es exclusivamente técnico y nunca depende de respuestas de empresa.
- *
- * Las columnas legacy permanecen temporalmente en PostgreSQL para una migración de
- * limpieza posterior a la validación del piloto, sin intervenir datos históricos a ciegas.
+ * Conserva las operaciones de planificación/equipo/Inventario ya probadas y aplica
+ * la clasificación técnica F4 del checklist. El contrato público de Inspección ya
+ * no expone título independiente ni fecha prevista de fin.
  */
 @Injectable()
 export class F4InspectionVisitsService extends InspectionVisitsService {
@@ -32,13 +27,13 @@ export class F4InspectionVisitsService extends InspectionVisitsService {
     const response = await super.list(query);
     return {
       ...response,
-      data: response.data.map((visit) => this.normalizeVisit(visit)),
+      data: response.data.map((visit) => this.normalizeChecklist(visit)),
     };
   }
 
   override async getById(id: string): Promise<InspectionVisitView> {
     await this.reclassifyCurrentChecklist(id);
-    return this.normalizeVisit(await super.getById(id));
+    return this.normalizeChecklist(await super.getById(id));
   }
 
   override async create(
@@ -48,7 +43,7 @@ export class F4InspectionVisitsService extends InspectionVisitsService {
   ): Promise<InspectionVisitView> {
     const created = await super.create(dto, principal, request);
     await this.reclassifyCurrentChecklist(created.id);
-    return this.normalizeVisit(await super.getById(created.id));
+    return this.normalizeChecklist(await super.getById(created.id));
   }
 
   override async generateChecklist(
@@ -58,27 +53,18 @@ export class F4InspectionVisitsService extends InspectionVisitsService {
   ): Promise<InspectionVisitView> {
     await super.generateChecklist(id, principal, request);
     await this.reclassifyCurrentChecklist(id);
-    return this.normalizeVisit(await super.getById(id));
+    return this.normalizeChecklist(await super.getById(id));
   }
 
-  private normalizeVisit<T extends { code: string; title: string; plannedEndAt: Date | null }>(visit: T): T {
-    const normalized = {
-      ...visit,
-      // Compatibilidad de contrato: consumidores antiguos reciben el identificador,
-      // no un segundo nombre persistente que pueda divergir.
-      title: visit.code,
-      plannedEndAt: null,
-    } as T;
-
-    if ('checklist' in normalized) {
-      const view = normalized as T & InspectionVisitView;
-      view.checklist = {
-        ...view.checklist,
-        companyOverdue: 0,
-        items: view.checklist.items.filter((item) => item.itemKind !== 'COMPANY_OVERDUE'),
-      };
-    }
-    return normalized;
+  private normalizeChecklist<T>(visit: T): T {
+    if (!visit || typeof visit !== 'object' || !('checklist' in visit)) return visit;
+    const view = visit as T & InspectionVisitView;
+    view.checklist = {
+      ...view.checklist,
+      companyOverdue: 0,
+      items: view.checklist.items.filter((item) => item.itemKind !== 'COMPANY_OVERDUE'),
+    };
+    return view;
   }
 
   private async reclassifyCurrentChecklist(visitId: string): Promise<void> {

From b021189a9420b5fad6078dfc91138c756dff08ae Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:42:32 -0300
Subject: [PATCH 146/224] refactor(f4): remove inspection title from report
 contracts

---
 .../inspection-reports/inspection-reports.service.ts | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-reports.service.ts b/api-v3/src/inspection-reports/inspection-reports.service.ts
index 83a7f36..f4531f6 100644
--- a/api-v3/src/inspection-reports/inspection-reports.service.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.service.ts
@@ -56,7 +56,7 @@ export interface InspectionReportListItem {
     urgency: string;
     deadlineAt: Date | null;
   };
-  visit: { id: string; code: string; title: string; status: string };
+  visit: { id: string; code: string; status: string };
   companies: ContextAsset[];
   areas: ContextAsset[];
   findingCount: number;
@@ -76,7 +76,6 @@ export interface PendingInspectionReportItem {
   sealedAt: Date;
   closureSha256: string;
   visitCode: string;
-  visitTitle: string;
   companies: ContextAsset[];
   areas: ContextAsset[];
   findingCount: number;
@@ -152,7 +151,6 @@ export class InspectionReportsService {
         act.code ILIKE ${search}
         OR act.title ILIKE ${search}
         OR visit.code ILIKE ${search}
-        OR visit.title ILIKE ${search}
       )`);
     }
     if (query.year) conditions.push(`act.act_year = ${add(query.year)}`);
@@ -194,7 +192,6 @@ export class InspectionReportsService {
         act.sealed_at AS "sealedAt",
         act.closure_sha256 AS "closureSha256",
         visit.code AS "visitCode",
-        visit.title AS "visitTitle",
         COALESCE(context.companies, '[]'::jsonb) AS companies,
         COALESCE(context.areas, '[]'::jsonb) AS areas,
         COALESCE(finding_count.total, 0)::integer AS "findingCount"
@@ -259,8 +256,7 @@ export class InspectionReportsService {
         act.current_version AS "currentVersion",
         act.closure_sha256 AS "closureSha256",
         act.occurred_at AS "occurredAt",
-        visit.code AS "visitCode",
-        visit.title AS "visitTitle"
+        visit.code AS "visitCode"
       FROM inspection_acts act
       INNER JOIN inspection_visits visit ON visit.id = act.visit_id
       WHERE act.id = $1
@@ -277,7 +273,6 @@ export class InspectionReportsService {
       closureSha256: string | null;
       occurredAt: Date;
       visitCode: string;
-      visitTitle: string;
     }>;
     if (!act) throw actNotFound();
     if (act.status !== InspectionActStatus.SEALED || !act.closureSha256) {
@@ -390,7 +385,6 @@ export class InspectionReportsService {
         OR act.code ILIKE ${search}
         OR act.title ILIKE ${search}
         OR visit.code ILIKE ${search}
-        OR visit.title ILIKE ${search}
       )`);
     }
     if (query.year) conditions.push(`report.report_year = ${add(query.year)}`);
@@ -475,7 +469,7 @@ export class InspectionReportsService {
           'urgency',act.urgency,'deadlineAt',act.deadline_at
         ) AS act,
         JSONB_BUILD_OBJECT(
-          'id',visit.id,'code',visit.code,'title',visit.title,'status',visit.status
+          'id',visit.id,'code',visit.code,'status',visit.status
         ) AS visit,
         COALESCE(context.companies,'[]'::jsonb) AS companies,
         COALESCE(context.areas,'[]'::jsonb) AS areas,

From 2d2a2682201a1b5a6b57536a6df8b3b500942134 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:43:09 -0300
Subject: [PATCH 147/224] refactor(f4): remove inspection title from report web
 contract

---
 web-v2/src/lib/reportWorkflowApi.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/web-v2/src/lib/reportWorkflowApi.ts b/web-v2/src/lib/reportWorkflowApi.ts
index db1d3a6..b4cf29c 100644
--- a/web-v2/src/lib/reportWorkflowApi.ts
+++ b/web-v2/src/lib/reportWorkflowApi.ts
@@ -60,7 +60,7 @@ export interface InspectionReportDetailF4 {
     urgency: string;
     deadlineAt: string | null;
   };
-  visit: { id: string; code: string; title: string; status: string };
+  visit: { id: string; code: string; status: string };
   companies: Array<{ id: string; code: string; name: string }>;
   areas: Array<{ id: string; code: string; name: string }>;
   findingCount: number;
@@ -76,7 +76,6 @@ export interface PendingInspectionReportF4 {
   sealedAt: string;
   closureSha256: string;
   visitCode: string;
-  visitTitle: string;
   companies: Array<{ id: string; code: string; name: string }>;
   areas: Array<{ id: string; code: string; name: string }>;
   findingCount: number;

From 0df7935b5451b2a52c5eddf0e871efa61c0dd935 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:43:52 -0300
Subject: [PATCH 148/224] refactor(f4): remove inspection title from reports UI

---
 web-v2/src/pages/ReportsPage.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/web-v2/src/pages/ReportsPage.tsx b/web-v2/src/pages/ReportsPage.tsx
index ffc90e2..def6ed2 100644
--- a/web-v2/src/pages/ReportsPage.tsx
+++ b/web-v2/src/pages/ReportsPage.tsx
@@ -158,7 +158,7 @@ export function ReportsPage() {
       </tr>) : pending.map((item) => <tr key={item.actId}>
         <td><div className="document-primary"><strong>{item.actCode}</strong><small>{item.actTitle} · {formatDate(item.occurredAt)}</small></div></td>
         <td><div className="document-primary"><strong>{contextLabel(item.companies, 'Empresa sin asignar')}</strong><small>{contextLabel(item.areas, 'Área sin asignar')}</small></div></td>
-        <td><Link className="text-link" to={`/inspecciones/${item.visitId}`}>{item.visitCode}<small className="block-muted">{item.visitTitle}</small></Link></td>
+        <td><Link className="text-link" to={`/inspecciones/${item.visitId}`}>{item.visitCode}</Link></td>
         <td><Link className="text-link" to={`/hallazgos?search=${encodeURIComponent(item.actCode)}`}>{item.findingCount}</Link></td>
         <td>{formatDate(item.sealedAt)}</td>
         <td className="action-cell"><Link className="icon-button" to={`/inspecciones/actas/${item.actId}`} aria-label={`Abrir ${item.actCode}`}><Icon name="chevron" /></Link></td>

From 5386ccf9b562109fd56fa956c9b2a571a9f78c3f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:46:34 -0300
Subject: [PATCH 149/224] refactor(f4): remove inspection title from
 verification contracts

---
 .../inspection-verifications.service.ts             | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/api-v3/src/inspection-verifications/inspection-verifications.service.ts b/api-v3/src/inspection-verifications/inspection-verifications.service.ts
index eb55fb5..5ef3e06 100644
--- a/api-v3/src/inspection-verifications/inspection-verifications.service.ts
+++ b/api-v3/src/inspection-verifications/inspection-verifications.service.ts
@@ -27,7 +27,6 @@ interface VerificationContextView {
 interface VerificationVisitView {
   id: string;
   code: string;
-  title: string;
   status: InspectionVisitStatus;
   plannedStartAt: Date | null;
 }
@@ -42,7 +41,7 @@ export interface VerificationPlanningItem {
   company: VerificationContextView | null;
   area: VerificationContextView | null;
   act: { id: string; code: string };
-  sourceVisit: { id: string; code: string; title: string };
+  sourceVisit: { id: string; code: string };
   verificationVisit: VerificationVisitView | null;
 }
 
@@ -128,7 +127,6 @@ export class InspectionVerificationsService {
         SELECT
           visit.id,
           visit.code,
-          visit.title,
           visit.status,
           visit.planned_start_at AS "plannedStartAt"
         FROM inspection_finding_verification_visits verification_link
@@ -195,13 +193,11 @@ export class InspectionVerificationsService {
         jsonb_build_object('id', act.id, 'code', act.code) AS act,
         jsonb_build_object(
           'id', source_visit.id,
-          'code', source_visit.code,
-          'title', source_visit.title
+          'code', source_visit.code
         ) AS "sourceVisit",
         CASE WHEN verification_visit.id IS NULL THEN NULL ELSE jsonb_build_object(
           'id', verification_visit.id,
           'code', verification_visit.code,
-          'title', verification_visit.title,
           'status', verification_visit.status,
           'plannedStartAt', verification_visit."plannedStartAt"
         ) END AS "verificationVisit"
@@ -559,7 +555,6 @@ export class InspectionVerificationsService {
       const companyName = rows[0]?.companyName ?? 'Empresa';
       const areaName = rows[0]?.areaName ?? 'Área';
       const code = await nextInspectionVisitCode(manager, plannedStartAt);
-      const title = code;
       const findingCodes = rows.map((row) => row.code).join(', ');
       const notes = dto.notes?.trim() || null;
       const instructions = [
@@ -569,7 +564,8 @@ export class InspectionVerificationsService {
 
       const visit = manager.getRepository(InspectionVisit).create({
         code,
-        title,
+        // Compatibilidad temporal de persistencia hasta retirar la columna legacy.
+        title: code,
         objective: 'Verificar en campo la resolución de hallazgos con fecha de control programada.',
         status: InspectionVisitStatus.DRAFT,
         scopeAssetId: areaId,
@@ -650,7 +646,6 @@ export class InspectionVerificationsService {
         visit: {
           id: visit.id,
           code: visit.code,
-          title: visit.title,
           status: visit.status,
           plannedStartAt: visit.plannedStartAt,
         },

From a9b2ed4b4b2ffe6bc9bce29b42c3816dc0466771 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:49:29 -0300
Subject: [PATCH 150/224] fix(f4): decouple GEDO officialization from
 notification deadline

---
 .../inspection-report-workflow.service.ts     | 93 ++-----------------
 1 file changed, 9 insertions(+), 84 deletions(-)

diff --git a/api-v3/src/inspection-reports/inspection-report-workflow.service.ts b/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
index 41d06d3..1ef9d01 100644
--- a/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
+++ b/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
@@ -5,7 +5,6 @@ import {
   BadRequestException,
   ConflictException,
   Injectable,
-  InternalServerErrorException,
   NotFoundException,
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
@@ -15,9 +14,6 @@ import { AuditService } from '../audit/audit.service';
 import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
 import {
   AuditAction,
-  InspectionActUrgency,
-  InspectionDeadlineBasis,
-  InspectionDeadlineDayType,
   InspectionReportStatus,
 } from '../database/entities';
 import type { CreateInspectionReportFollowUpDto } from './dto/create-inspection-report-follow-up.dto';
@@ -169,7 +165,9 @@ export class InspectionReportWorkflowService {
           file!.buffer.length,
           sha256,
         ]);
-        await this.activateNonUrgentDeadline(manager, report.actId, officializedAt);
+        // GEDO oficializa el INF, pero no equivale por sí solo a la notificación
+        // administrativa de un Acta no urgente. El vencimiento queda pendiente
+        // hasta que el procedimiento defina y registre el evento de notificación.
         await this.audit.record({
           ...administrationAuditContext(principal, request),
           action: AuditAction.INSPECTION_REPORT_OFFICIALIZED,
@@ -182,7 +180,12 @@ export class InspectionReportWorkflowService {
             gedoPdfOriginalName: file!.originalname,
             gedoPdfSha256: sha256,
           },
-          metadata: { reportCode: report.code, actId: report.actId, immutable: true },
+          metadata: {
+            reportCode: report.code,
+            actId: report.actId,
+            immutable: true,
+            deadlineActivation: 'PENDING_NOTIFICATION_EVENT',
+          },
         }, manager);
         return this.getWorkflowView(manager, reportId);
       });
@@ -288,84 +291,6 @@ export class InspectionReportWorkflowService {
     `, [reportId]);
   }
 
-  private async activateNonUrgentDeadline(
-    manager: EntityManager,
-    actId: string,
-    officializedAt: Date,
-  ): Promise<void> {
-    const [act] = await manager.query(`
-      SELECT urgency,deadline_days AS "deadlineDays",deadline_day_type AS "deadlineDayType",
-             deadline_basis AS "deadlineBasis",deadline_at AS "deadlineAt"
-      FROM inspection_acts WHERE id=$1 FOR UPDATE
-    `, [actId]) as Array<{
-      urgency: InspectionActUrgency;
-      deadlineDays: number | null;
-      deadlineDayType: InspectionDeadlineDayType | null;
-      deadlineBasis: InspectionDeadlineBasis | null;
-      deadlineAt: Date | null;
-    }>;
-    if (!act) return;
-    if (act.urgency !== InspectionActUrgency.NON_URGENT) return;
-    if (act.deadlineBasis !== InspectionDeadlineBasis.GEDO_DATE) {
-      throw new ConflictException({
-        code: 'INVALID_NON_URGENT_DEADLINE_BASIS',
-        message: 'El acta no urgente no conserva la regla GEDO necesaria para calcular su vencimiento',
-      });
-    }
-    if (!act.deadlineDays || !act.deadlineDayType) {
-      throw new ConflictException({
-        code: 'MISSING_ACT_DEADLINE_SNAPSHOT',
-        message: 'El acta no conserva la política de plazo aplicada al momento de finalizarse',
-      });
-    }
-    const deadlineAt = await this.calculateDeadline(
-      manager,
-      officializedAt,
-      Number(act.deadlineDays),
-      act.deadlineDayType,
-    );
-    await manager.query(`
-      UPDATE inspection_acts
-      SET deadline_base_at=$2,deadline_at=$3,updated_at=CURRENT_TIMESTAMP
-      WHERE id=$1
-    `, [actId, officializedAt, deadlineAt]);
-  }
-
-  private async calculateDeadline(
-    manager: EntityManager,
-    baseAt: Date,
-    days: number,
-    dayType: InspectionDeadlineDayType,
-  ): Promise<Date> {
-    if (dayType === InspectionDeadlineDayType.CALENDAR) {
-      const [row] = await manager.query(`
-        SELECT (
-          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + $2::integer)::timestamp
-          + time '23:59:59'
-        ) AT TIME ZONE 'America/Argentina/Mendoza' AS due_at
-      `, [baseAt, days]) as Array<{ due_at: Date }>;
-      return row.due_at;
-    }
-    const [row] = await manager.query(`
-      WITH candidates AS (
-        SELECT day::date AS day,
-          COALESCE(override.is_business_day, EXTRACT(ISODOW FROM day)::integer BETWEEN 1 AND 5) AS business
-        FROM generate_series(
-          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + 1)::timestamp,
-          (($1::timestamptz AT TIME ZONE 'America/Argentina/Mendoza')::date + 730)::timestamp,
-          interval '1 day'
-        ) day
-        LEFT JOIN inspection_business_calendar_days override ON override.date=day::date
-      ), ranked AS (
-        SELECT day,ROW_NUMBER() OVER (ORDER BY day) AS position FROM candidates WHERE business=true
-      )
-      SELECT ((day::timestamp + time '23:59:59') AT TIME ZONE 'America/Argentina/Mendoza') AS due_at
-      FROM ranked WHERE position=$2 LIMIT 1
-    `, [baseAt, days]) as Array<{ due_at: Date }>;
-    if (!row?.due_at) throw new InternalServerErrorException('No se pudo calcular el vencimiento');
-    return row.due_at;
-  }
-
   private assertPdf(file: UploadedInspectionReportFile | undefined): void {
     if (!file?.buffer?.length) {
       throw new BadRequestException({

From 98545820ac11156c0078fb60163e958a02eb83da Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:50:39 -0300
Subject: [PATCH 151/224] refactor(f4): model nonurgent deadline on
 notification date

---
 api-v3/src/database/entities/inspection-act.entity.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api-v3/src/database/entities/inspection-act.entity.ts b/api-v3/src/database/entities/inspection-act.entity.ts
index 3e9021f..8759cda 100644
--- a/api-v3/src/database/entities/inspection-act.entity.ts
+++ b/api-v3/src/database/entities/inspection-act.entity.ts
@@ -23,7 +23,7 @@ export enum InspectionDeadlineDayType {
 
 export enum InspectionDeadlineBasis {
   ACT_DATE = 'ACT_DATE',
-  GEDO_DATE = 'GEDO_DATE',
+  NOTIFICATION_DATE = 'NOTIFICATION_DATE',
 }
 
 @Entity({ name: 'inspection_acts' })

From a816f4cfdfae7876cab3d35f5c57f308cc13f2cf Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 07:51:33 -0300
Subject: [PATCH 152/224] fix(f4): keep legacy deadline storage compatible
 pending notification definition

---
 api-v3/src/database/entities/inspection-act.entity.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/api-v3/src/database/entities/inspection-act.entity.ts b/api-v3/src/database/entities/inspection-act.entity.ts
index 8759cda..9f0b0f0 100644
--- a/api-v3/src/database/entities/inspection-act.entity.ts
+++ b/api-v3/src/database/entities/inspection-act.entity.ts
@@ -23,7 +23,11 @@ export enum InspectionDeadlineDayType {
 
 export enum InspectionDeadlineBasis {
   ACT_DATE = 'ACT_DATE',
-  NOTIFICATION_DATE = 'NOTIFICATION_DATE',
+  // La columna F4 temprana usó GEDO_DATE. Se conserva el valor físico por
+  // compatibilidad de migración, pero funcionalmente significa "pendiente de
+  // fecha de notificación" hasta que el procedimiento defina el evento válido.
+  NOTIFICATION_DATE = 'GEDO_DATE',
+  GEDO_DATE = 'GEDO_DATE',
 }
 
 @Entity({ name: 'inspection_acts' })

From 459ad033263d38a375b869f83110580a83cd8a48 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:11:33 -0300
Subject: [PATCH 153/224] fix(f4): decouple finding worklist from inspection
 title

---
 .../inspection-finding-worklist.service.ts                    | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/api-v3/src/inspection-findings/inspection-finding-worklist.service.ts b/api-v3/src/inspection-findings/inspection-finding-worklist.service.ts
index 0838a2d..42df273 100644
--- a/api-v3/src/inspection-findings/inspection-finding-worklist.service.ts
+++ b/api-v3/src/inspection-findings/inspection-finding-worklist.service.ts
@@ -44,7 +44,6 @@ export interface InspectionFindingWorklistItem {
   verificationVisit: {
     id: string;
     code: string;
-    title: string;
     status: string;
     plannedStartAt: Date | null;
   } | null;
@@ -214,7 +213,6 @@ export class InspectionFindingWorklistService {
         CASE WHEN verification_visit.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
           'id', verification_visit.id,
           'code', verification_visit.code,
-          'title', verification_visit.title,
           'status', verification_visit.status,
           'plannedStartAt', verification_visit.planned_start_at
         ) END AS "verificationVisit",
@@ -235,7 +233,7 @@ export class InspectionFindingWorklistService {
       FROM inspection_findings finding
       ${joins}
       LEFT JOIN LATERAL (
-        SELECT verification_target.id, verification_target.code, verification_target.title,
+        SELECT verification_target.id, verification_target.code,
           verification_target.status, verification_target.planned_start_at
         FROM inspection_finding_verification_visits verification_link
         INNER JOIN inspection_visits verification_target ON verification_target.id = verification_link.visit_id

From c53997a41cf6cc82315fc572802ff9c0a54c284a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:11:46 -0300
Subject: [PATCH 154/224] fix(f4): align finding worklist web contract

---
 web-v2/src/lib/findingWorklistF4Api.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/web-v2/src/lib/findingWorklistF4Api.ts b/web-v2/src/lib/findingWorklistF4Api.ts
index abe1491..d342828 100644
--- a/web-v2/src/lib/findingWorklistF4Api.ts
+++ b/web-v2/src/lib/findingWorklistF4Api.ts
@@ -41,7 +41,6 @@ export interface FindingWorklistItemF4 {
   verificationVisit: {
     id: string;
     code: string;
-    title: string;
     status: string;
     plannedStartAt: string | null;
   } | null;

From 048b7b90af7c396b8aeebe4c3236ef7e9b864a46 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:16:29 -0300
Subject: [PATCH 155/224] fix(f4): remove inspection title from Android
 contract

---
 .../src/main/java/com/korexlabs/dhinspeccion/data/DhMobile.kt   | 2 --
 1 file changed, 2 deletions(-)

diff --git a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/DhMobile.kt b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/DhMobile.kt
index 87bff44..b7e5eec 100644
--- a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/DhMobile.kt
+++ b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/DhMobile.kt
@@ -90,7 +90,6 @@ data class PersonSummary(
 data class VisitSummary(
     val id: String,
     val code: String,
-    val title: String? = null,
     val objective: String? = null,
     val status: String,
     val scopeAsset: AssetSummary? = null,
@@ -153,7 +152,6 @@ data class ChecklistSummary(
 data class VisitDetail(
     val id: String,
     val code: String,
-    val title: String? = null,
     val objective: String? = null,
     val status: String,
     val operationalArea: AssetSummary? = null,

From 49b321ca87a5cd3fb8d54e4063367004720397eb Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:26:31 -0300
Subject: [PATCH 156/224] fix(f4): remove inspection title from asset dossier

---
 api-v3/src/asset-master/assets.service.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/api-v3/src/asset-master/assets.service.ts b/api-v3/src/asset-master/assets.service.ts
index 53a6481..f2fb7a4 100644
--- a/api-v3/src/asset-master/assets.service.ts
+++ b/api-v3/src/asset-master/assets.service.ts
@@ -298,7 +298,7 @@ export class AssetsService {
 
     const [visits, acts, findings, evidence, communications, verificationResults, documents, inspectionReports, media, versions] = await Promise.all([
       this.dataSource.query(
-        `SELECT DISTINCT visit.id, visit.code, visit.title, visit.status,
+        `SELECT DISTINCT visit.id, visit.code, visit.status,
                 visit.planned_start_at AS "plannedStartAt",
                 visit.actual_started_at AS "actualStartedAt",
                 visit.actual_closed_at AS "actualClosedAt",
@@ -322,7 +322,7 @@ export class AssetsService {
         `SELECT DISTINCT act.id, act.visit_id AS "visitId", act.code, act.status,
                 act.occurred_at AS "occurredAt", act.title, act.summary,
                 act.closed_at AS "closedAt", act.current_version AS "currentVersion",
-                visit.code AS "visitCode", visit.title AS "visitTitle"
+                visit.code AS "visitCode"
          FROM inspection_acts act
          JOIN inspection_visits visit ON visit.id = act.visit_id
          LEFT JOIN inspection_act_assets act_asset
@@ -342,7 +342,7 @@ export class AssetsService {
                 finding.closed_at AS "closedAt", finding.closure_notes AS "closureNotes",
                 finding.created_at AS "createdAt", finding.updated_at AS "updatedAt",
                 act.code AS "actCode", act.occurred_at AS "actOccurredAt",
-                visit.id AS "visitId", visit.code AS "visitCode", visit.title AS "visitTitle"
+                visit.id AS "visitId", visit.code AS "visitCode"
          FROM inspection_findings finding
          JOIN inspection_acts act ON act.id = finding.act_id
          JOIN inspection_visits visit ON visit.id = act.visit_id
@@ -389,7 +389,7 @@ export class AssetsService {
                 verification_link.result_recorded_at AS "resultRecordedAt",
                 verification_link.rescheduled_control_on AS "rescheduledControlOn",
                 finding.code AS "findingCode", finding.title AS "findingTitle",
-                visit.code AS "visitCode", visit.title AS "visitTitle", visit.status AS "visitStatus",
+                visit.code AS "visitCode", visit.status AS "visitStatus",
                 (SELECT COUNT(*)::integer
                  FROM inspection_finding_evidence verification_evidence
                  WHERE verification_evidence.finding_id = finding.id
@@ -484,7 +484,7 @@ export class AssetsService {
       kind: 'INSPECTION',
       occurredAt: visit.actualStartedAt ?? visit.plannedStartAt ?? visit.createdAt,
       title: `Inspección ${String(visit.code)}`,
-      description: visit.title,
+      description: null,
       href: `/inspecciones/${String(visit.id)}`,
       meta: { status: visit.status },
     }));
@@ -867,7 +867,7 @@ export class AssetsService {
   private fieldDiscoverySelect(): string {
     return `SELECT discovery.id, discovery.status, discovery.discovery_notes AS "discoveryNotes", discovery.observed_at AS "observedAt", discovery.reviewed_at AS "reviewedAt", discovery.review_notes AS "reviewNotes", discovery.created_at AS "createdAt",
       JSONB_BUILD_OBJECT('id',asset.id,'code',asset.code,'name',asset.name,'commonName',asset.common_name,'informationStatus',asset.information_status,'typeId',asset.asset_type_id,'typeName',asset_type.name,'parentId',asset.parent_id,'operationalAreaId',asset.operational_area_id,'operatorCompanyId',asset.operator_company_id) AS asset,
-      JSONB_BUILD_OBJECT('id',visit.id,'code',visit.code,'title',visit.title,'status',visit.status) AS visit,
+      JSONB_BUILD_OBJECT('id',visit.id,'code',visit.code,'status',visit.status) AS visit,
       JSONB_BUILD_OBJECT('id',creator.id,'username',creator.username,'firstName',creator.first_name,'lastName',creator.last_name) AS creator,
       CASE WHEN reviewer.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id',reviewer.id,'username',reviewer.username,'firstName',reviewer.first_name,'lastName',reviewer.last_name) END AS reviewer,
       CASE WHEN matched.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id',matched.id,'code',matched.code,'name',matched.name,'commonName',matched.common_name) END AS "matchedAsset"

From 5404409042c493133a1d0371cee33f006db62ab3 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:45:54 -0300
Subject: [PATCH 157/224] refactor(f4): retire legacy inspection fields

---
 ...0000-f4-remove-inspection-legacy-fields.ts | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts

diff --git a/api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts b/api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts
new file mode 100644
index 0000000..4555137
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts
@@ -0,0 +1,77 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * F4 elimina dos campos heredados de la planificación original de Inspecciones:
+ * - title: la Inspección se identifica por su código autogenerado.
+ * - planned_end_at: la planificación sólo define la fecha/hora prevista de inicio.
+ *
+ * Se conserva un índice sobre planned_start_at porque sigue siendo un criterio de
+ * orden y filtro operativo. El rollback reconstruye la forma original de D1.
+ */
+export class F4RemoveInspectionLegacyFields1790000500000 implements MigrationInterface {
+  name = 'F4RemoveInspectionLegacyFields1790000500000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS idx_inspection_visits_planned_dates`);
+    await queryRunner.query(`
+      ALTER TABLE inspection_visits
+      DROP CONSTRAINT IF EXISTS chk_inspection_visits_planned_dates
+    `);
+
+    await queryRunner.query(`ALTER TABLE inspection_visits DROP COLUMN IF EXISTS planned_end_at`);
+    await queryRunner.query(`ALTER TABLE inspection_visits DROP COLUMN IF EXISTS title`);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_start_at
+      ON inspection_visits (planned_start_at)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS idx_inspection_visits_planned_start_at`);
+
+    await queryRunner.query(`
+      ALTER TABLE inspection_visits
+      ADD COLUMN IF NOT EXISTS title varchar(200)
+    `);
+    await queryRunner.query(`
+      UPDATE inspection_visits
+      SET title = code
+      WHERE title IS NULL
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_visits
+      ALTER COLUMN title SET NOT NULL
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE inspection_visits
+      ADD COLUMN IF NOT EXISTS planned_end_at timestamptz
+    `);
+
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'chk_inspection_visits_planned_dates'
+            AND conrelid = 'inspection_visits'::regclass
+        ) THEN
+          ALTER TABLE inspection_visits
+          ADD CONSTRAINT chk_inspection_visits_planned_dates CHECK (
+            planned_start_at IS NULL
+            OR planned_end_at IS NULL
+            OR planned_end_at >= planned_start_at
+          );
+        END IF;
+      END
+      $$
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_dates
+      ON inspection_visits (planned_start_at, planned_end_at)
+    `);
+  }
+}

From e6ae2807bce091124b59f229a517289a78599fb5 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:46:15 -0300
Subject: [PATCH 158/224] refactor(f4): align inspection entity with retired
 columns

---
 .../database/entities/inspection-visit.entity.ts | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/api-v3/src/database/entities/inspection-visit.entity.ts b/api-v3/src/database/entities/inspection-visit.entity.ts
index 23f3b5c..6f04202 100644
--- a/api-v3/src/database/entities/inspection-visit.entity.ts
+++ b/api-v3/src/database/entities/inspection-visit.entity.ts
@@ -14,7 +14,7 @@ export enum InspectionVisitStatus {
 @Index('idx_inspection_visits_status', ['status'])
 @Index('idx_inspection_visits_scope_asset_id', ['scopeAssetId'])
 @Index('idx_inspection_visits_lead_inspector_user_id', ['leadInspectorUserId'])
-@Index('idx_inspection_visits_planned_dates', ['plannedStartAt', 'plannedEndAt'])
+@Index('idx_inspection_visits_planned_start_at', ['plannedStartAt'])
 @Index('idx_inspection_visits_operational_context', ['operationalAreaId', 'operatorCompanyId'])
 export class InspectionVisit extends TimestampedEntity {
   @PrimaryGeneratedColumn('uuid')
@@ -23,8 +23,11 @@ export class InspectionVisit extends TimestampedEntity {
   @Column({ type: 'varchar', length: 80 })
   code!: string;
 
-  @Column({ type: 'varchar', length: 200 })
-  title!: string;
+  /**
+   * Compatibilidad TypeScript transitoria con el constructor de Inspecciones.
+   * No es una columna ORM: F4 retiró inspection_visits.title físicamente.
+   */
+  title?: string;
 
   @Column({ type: 'text', nullable: true })
   objective!: string | null;
@@ -47,8 +50,11 @@ export class InspectionVisit extends TimestampedEntity {
   @Column({ name: 'planned_start_at', type: 'timestamptz', nullable: true })
   plannedStartAt!: Date | null;
 
-  @Column({ name: 'planned_end_at', type: 'timestamptz', nullable: true })
-  plannedEndAt!: Date | null;
+  /**
+   * Compatibilidad TypeScript transitoria con el constructor de Inspecciones.
+   * No es una columna ORM: F4 retiró inspection_visits.planned_end_at físicamente.
+   */
+  plannedEndAt?: Date | null;
 
   @Column({ name: 'actual_started_at', type: 'timestamptz', nullable: true })
   actualStartedAt!: Date | null;

From f70962a819be7ebe60c79f224e497f000c136b2a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:50:27 -0300
Subject: [PATCH 159/224] refactor(f4): remove inspection legacy persistence
 shim

---
 api-v3/src/inspection-visits/inspection-visits.service.ts | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/api-v3/src/inspection-visits/inspection-visits.service.ts b/api-v3/src/inspection-visits/inspection-visits.service.ts
index b4208b7..b2cf21d 100644
--- a/api-v3/src/inspection-visits/inspection-visits.service.ts
+++ b/api-v3/src/inspection-visits/inspection-visits.service.ts
@@ -318,9 +318,6 @@ export class InspectionVisitsService {
         const code = await nextInspectionVisitCode(manager, plannedStartAt);
         const visit = manager.getRepository(InspectionVisit).create({
           code,
-          // Compatibilidad de persistencia temporal: estas dos columnas legacy se
-          // conservan hasta eliminar sus últimas lecturas históricas del repositorio.
-          title: code,
           objective: null,
           status: InspectionVisitStatus.DRAFT,
           scopeAssetId: operationalAreaId,
@@ -328,7 +325,6 @@ export class InspectionVisitsService {
           operatorCompanyId,
           leadInspectorUserId: dto.leadInspectorUserId,
           plannedStartAt,
-          plannedEndAt: null,
           actualStartedAt: null,
           actualClosedAt: null,
           instructions: null,

From a9fc9f3e8e443968b8c80448d1e4ad20cb957644 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:50:42 -0300
Subject: [PATCH 160/224] refactor(f4): remove inspection legacy type shims

---
 .../src/database/entities/inspection-visit.entity.ts | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/api-v3/src/database/entities/inspection-visit.entity.ts b/api-v3/src/database/entities/inspection-visit.entity.ts
index 6f04202..e8eca62 100644
--- a/api-v3/src/database/entities/inspection-visit.entity.ts
+++ b/api-v3/src/database/entities/inspection-visit.entity.ts
@@ -23,12 +23,6 @@ export class InspectionVisit extends TimestampedEntity {
   @Column({ type: 'varchar', length: 80 })
   code!: string;
 
-  /**
-   * Compatibilidad TypeScript transitoria con el constructor de Inspecciones.
-   * No es una columna ORM: F4 retiró inspection_visits.title físicamente.
-   */
-  title?: string;
-
   @Column({ type: 'text', nullable: true })
   objective!: string | null;
 
@@ -50,12 +44,6 @@ export class InspectionVisit extends TimestampedEntity {
   @Column({ name: 'planned_start_at', type: 'timestamptz', nullable: true })
   plannedStartAt!: Date | null;
 
-  /**
-   * Compatibilidad TypeScript transitoria con el constructor de Inspecciones.
-   * No es una columna ORM: F4 retiró inspection_visits.planned_end_at físicamente.
-   */
-  plannedEndAt?: Date | null;
-
   @Column({ name: 'actual_started_at', type: 'timestamptz', nullable: true })
   actualStartedAt!: Date | null;
 

From 2506bece76eb6c441dd4e7f5b691081ce71f2ab8 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 08:52:09 -0300
Subject: [PATCH 161/224] test(f4): guard retired inspection fields

---
 .../unit/f4-inspection-legacy-fields.test.ts  | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 api-v3/test/unit/f4-inspection-legacy-fields.test.ts

diff --git a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
new file mode 100644
index 0000000..476f8d8
--- /dev/null
+++ b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { getMetadataArgsStorage, type QueryRunner } from 'typeorm';
+import { InspectionVisit } from '../../src/database/entities/inspection-visit.entity';
+import { F4RemoveInspectionLegacyFields1790000500000 } from '../../src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields';
+
+test('F4: InspectionVisit no vuelve a mapear title ni plannedEndAt', () => {
+  const metadata = getMetadataArgsStorage();
+  const columns = metadata.columns
+    .filter((column) => column.target === InspectionVisit)
+    .map((column) => column.propertyName);
+  const indexes = metadata.indices
+    .filter((index) => index.target === InspectionVisit)
+    .map((index) => index.name);
+
+  assert.equal(columns.includes('title'), false);
+  assert.equal(columns.includes('plannedEndAt'), false);
+  assert.equal(columns.includes('plannedStartAt'), true);
+  assert.equal(indexes.includes('idx_inspection_visits_planned_dates'), false);
+  assert.equal(indexes.includes('idx_inspection_visits_planned_start_at'), true);
+});
+
+test('F4: la migración retira las columnas legacy y conserva índice de inicio', async () => {
+  const statements: string[] = [];
+  const queryRunner = {
+    query: async (sql: string) => {
+      statements.push(sql.replace(/\s+/g, ' ').trim());
+      return [];
+    },
+  } as unknown as QueryRunner;
+
+  await new F4RemoveInspectionLegacyFields1790000500000().up(queryRunner);
+  const sql = statements.join('\n');
+
+  assert.match(sql, /DROP COLUMN IF EXISTS planned_end_at/i);
+  assert.match(sql, /DROP COLUMN IF EXISTS title/i);
+  assert.match(sql, /DROP CONSTRAINT IF EXISTS chk_inspection_visits_planned_dates/i);
+  assert.match(sql, /CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_start_at/i);
+  assert.doesNotMatch(sql, /CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_dates/i);
+});
+
+test('F4: el rollback reconstruye la forma histórica de D1', async () => {
+  const statements: string[] = [];
+  const queryRunner = {
+    query: async (sql: string) => {
+      statements.push(sql.replace(/\s+/g, ' ').trim());
+      return [];
+    },
+  } as unknown as QueryRunner;
+
+  await new F4RemoveInspectionLegacyFields1790000500000().down(queryRunner);
+  const sql = statements.join('\n');
+
+  assert.match(sql, /ADD COLUMN IF NOT EXISTS title varchar\(200\)/i);
+  assert.match(sql, /UPDATE inspection_visits SET title = code WHERE title IS NULL/i);
+  assert.match(sql, /ALTER COLUMN title SET NOT NULL/i);
+  assert.match(sql, /ADD COLUMN IF NOT EXISTS planned_end_at timestamptz/i);
+  assert.match(sql, /ADD CONSTRAINT chk_inspection_visits_planned_dates CHECK/i);
+  assert.match(sql, /CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_dates/i);
+});

From 71d0884557475de9dd53a72667e73cac9c4acd87 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:07:05 -0300
Subject: [PATCH 162/224] fix: decouple act locking from visit verification
 completion

---
 .../inspection-closing.service.ts               | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/api-v3/src/inspection-closing/inspection-closing.service.ts b/api-v3/src/inspection-closing/inspection-closing.service.ts
index 8953f74..253a4e4 100644
--- a/api-v3/src/inspection-closing/inspection-closing.service.ts
+++ b/api-v3/src/inspection-closing/inspection-closing.service.ts
@@ -277,7 +277,6 @@ export class InspectionClosingService {
       this.assertDraftInProgress(act, visit);
       await this.assertActorAssigned(manager, visit.id, principal, true);
       await this.requireResponsible(manager, actId);
-      await this.assertVerificationResultsComplete(manager, visit.id);
       if (await this.signatureCount(manager, actId)) {
         throw new ConflictException({
           code: 'INSPECTION_ACT_ALREADY_SIGNED',
@@ -935,22 +934,6 @@ export class InspectionClosingService {
     };
   }
 
-  private async assertVerificationResultsComplete(manager: EntityManager, inspectionId: string): Promise<void> {
-    const [row] = await manager.query(`
-      SELECT
-        COUNT(*)::integer AS total,
-        COUNT(*) FILTER (WHERE outcome IS NOT NULL)::integer AS completed
-      FROM inspection_finding_verification_visits
-      WHERE visit_id=$1
-    `, [inspectionId]) as Array<{ total: number; completed: number }>;
-    if (Number(row?.total ?? 0) > 0 && Number(row.completed) !== Number(row.total)) {
-      throw new ConflictException({
-        code: 'INSPECTION_VERIFICATION_RESULTS_REQUIRED',
-        message: 'Registrá el resultado de todas las verificaciones antes de finalizar el acta',
-      });
-    }
-  }
-
   private async deadlinePolicy(manager: EntityManager): Promise<DeadlinePolicy> {
     const [row] = await manager.query(`
       SELECT

From b24c3787c97a1d69b5c3b8b8073d9c2e066ffee0 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:08:00 -0300
Subject: [PATCH 163/224] fix: require verification results when closing
 inspection

---
 .../inspection-visit-lifecycle.service.ts      | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
index 013bfbe..cb1c4c5 100644
--- a/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
+++ b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
@@ -174,6 +174,7 @@ export class InspectionVisitLifecycleService {
           pendingActs: pending.map((act) => ({ id: act.id, code: act.code, status: act.status })),
         });
       }
+      await this.assertVerificationResultsComplete(manager, id);
 
       const serverClosedAt = new Date();
       const clientClosedAt = new Date(dto.clientClosedAt);
@@ -216,6 +217,7 @@ export class InspectionVisitLifecycleService {
           transition: 'CLOSE',
           source: 'ANDROID',
           allActsSealed: true,
+          allVerificationResultsRecorded: true,
         },
       }, manager);
     });
@@ -277,6 +279,22 @@ export class InspectionVisitLifecycleService {
     return visit;
   }
 
+  private async assertVerificationResultsComplete(manager: EntityManager, inspectionId: string): Promise<void> {
+    const [row] = await manager.query(`
+      SELECT
+        COUNT(*)::integer AS total,
+        COUNT(*) FILTER (WHERE outcome IS NOT NULL)::integer AS completed
+      FROM inspection_finding_verification_visits
+      WHERE visit_id=$1
+    `, [inspectionId]) as Array<{ total: number; completed: number }>;
+    if (Number(row?.total ?? 0) > 0 && Number(row.completed) !== Number(row.total)) {
+      throw new ConflictException({
+        code: 'INSPECTION_VERIFICATION_RESULTS_REQUIRED',
+        message: 'Registrá el resultado de todas las verificaciones antes de cerrar la Inspección',
+      });
+    }
+  }
+
   private async validatePlanningContext(manager: EntityManager, visit: InspectionVisit): Promise<void> {
     if (!visit.operationalAreaId || !visit.operatorCompanyId || !visit.leadInspectorUserId || !visit.plannedStartAt) {
       throw new ConflictException({

From 232614ccf0cb2c0dc9af5f9f529cb673899e2344 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:08:23 -0300
Subject: [PATCH 164/224] test: align multi-act contract with F4 lifecycle

---
 ...ase-f1-1-multi-act-operating-model.test.ts | 44 ++++++++-----------
 1 file changed, 19 insertions(+), 25 deletions(-)

diff --git a/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts b/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts
index f563b06..99beaa5 100644
--- a/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts
+++ b/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts
@@ -6,7 +6,7 @@ import test from 'node:test';
 const root = process.cwd();
 const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
 
-test('F1.1 migration allows many acts per inspection while keeping only one draft at a time', () => {
+test('F1.1/F4 allows many acts per inspection while keeping only one draft at a time', () => {
   const migration = read('src/database/migrations/1789495200000-phase-f1-1-multi-act-inspections.ts');
   assert.match(migration, /DROP CONSTRAINT IF EXISTS uq_inspection_acts_visit/);
   assert.match(migration, /CREATE UNIQUE INDEX uq_inspection_acts_one_draft_per_visit/);
@@ -15,7 +15,7 @@ test('F1.1 migration allows many acts per inspection while keeping only one draf
   assert.match(migration, /CREATE INDEX idx_inspection_reports_visit_id/);
 });
 
-test('F1.1 preserves exactly one frozen report per act instead of per inspection', () => {
+test('F1.1/F4 preserves exactly one frozen report per act instead of per inspection', () => {
   const reportEntity = read('src/database/entities/inspection-report.entity.ts');
   const reports = read('src/inspection-reports/inspection-reports.service.ts');
   assert.match(reportEntity, /@Index\('uq_inspection_reports_act', \['actId'\], \{ unique: true \}\)/);
@@ -24,43 +24,37 @@ test('F1.1 preserves exactly one frozen report per act instead of per inspection
   assert.match(reports, /WHERE act_id = \$1/);
 });
 
-test('F1.1 closes an act without closing its parent inspection', () => {
+test('F4 seals one act without closing its parent inspection', () => {
   const closing = read('src/inspection-closing/inspection-closing.service.ts');
   const closeBody = closing.slice(closing.indexOf('  async close('), closing.indexOf('  async signatureContent('));
   assert.match(closeBody, /UPDATE inspection_acts/);
+  assert.match(closeBody, /status='SEALED'/);
   assert.doesNotMatch(closeBody, /UPDATE inspection_visits/);
-  assert.match(closeBody, /visitRemainsIndependent: true/);
+  assert.match(closeBody, /inspectionRemainsIndependent: true/);
   assert.match(closeBody, /ensureFrozenReport\(manager, actId, principal, request\)/);
 });
 
-test('F1.1 exposes an APK-only explicit inspection close and permits pending company signature', () => {
-  const controller = read('src/inspection-visits/inspection-visits.controller.ts');
-  const visits = read('src/inspection-visits/inspection-visits.service.ts');
-  assert.match(controller, /@Post\(':id\/close'\)/);
-  assert.match(controller, /@RequirePermissions\('inspections\.execute'\)/);
-  assert.match(visits, /async close\(/);
-  assert.match(visits, /assertMobileInspector\(principal\)/);
-  assert.match(visits, /INSPECTION_VISIT_DRAFT_ACTS_PENDING/);
-  assert.match(visits, /INSPECTION_VISIT_INSPECTOR_SIGNATURE_PENDING/);
-  assert.match(visits, /pendingCompanySignatures/);
-  assert.match(visits, /actsMayCompleteCompanySignatureLater: true/);
+test('F4 closes an inspection only after every non-cancelled act is sealed', () => {
+  const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
+  const closeBody = lifecycle.slice(lifecycle.indexOf('  async close('), lifecycle.indexOf('  async cancel('));
+  assert.match(closeBody, /status<>'CANCELLED'/);
+  assert.match(closeBody, /acts\.filter\(\(act\) => act\.status !== 'SEALED'\)/);
+  assert.match(closeBody, /INSPECTION_REQUIRES_ACT/);
+  assert.match(closeBody, /INSPECTION_ACTS_NOT_SEALED/);
+  assert.match(closeBody, /assertVerificationResultsComplete\(manager, id\)/);
+  assert.match(closeBody, /visit\.status = InspectionVisitStatus\.CLOSED/);
 });
 
-test('F1.1 lets the company sign after the inspection closes and records conformity or dissent', () => {
+test('F4 requires a final company manifestation before an act can be sealed', () => {
   const closing = read('src/inspection-closing/inspection-closing.service.ts');
-  const dto = read('src/inspection-closing/dto/create-company-signature.dto.ts');
-  const signatureEntity = read('src/database/entities/inspection-act-signature.entity.ts');
-  assert.match(closing, /InspectionVisitStatus\.IN_PROGRESS, InspectionVisitStatus\.CLOSED/);
+  assert.match(closing, /INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED/);
+  assert.match(closing, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);
   assert.match(closing, /InspectionCompanySignatureManifestation\.CONFORMITY/);
   assert.match(closing, /InspectionCompanySignatureManifestation\.DISSENT/);
-  assert.match(dto, /@ValidateIf/);
-  assert.match(dto, /@MinLength\(10\)/);
-  assert.match(signatureEntity, /CONFORMITY = 'CONFORMITY'/);
-  assert.match(signatureEntity, /DISSENT = 'DISSENT'/);
-  assert.match(signatureEntity, /companyStatement/);
+  assert.match(closing, /InspectionActSignatureStatus\.REFUSED/);
 });
 
-test('F1.1 keeps field-created Inventory linked only to the current draft act', () => {
+test('F1.1/F4 keeps field-created Inventory linked only to the current draft act', () => {
   const link = read('src/inspection-operations/field-discovery-inspection-link.service.ts');
   assert.match(link, /AND status = 'DRAFT'/);
   assert.match(link, /if \(act\)/);

From 5bd392dcb466e37880992c0f1171db8013a7f7e6 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:08:42 -0300
Subject: [PATCH 165/224] test: move verification completion gate to inspection
 close

---
 .../unit/phase-d5-3-17-verification-execution.test.ts | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/api-v3/test/unit/phase-d5-3-17-verification-execution.test.ts b/api-v3/test/unit/phase-d5-3-17-verification-execution.test.ts
index 5c5919a..8d00165 100644
--- a/api-v3/test/unit/phase-d5-3-17-verification-execution.test.ts
+++ b/api-v3/test/unit/phase-d5-3-17-verification-execution.test.ts
@@ -6,6 +6,7 @@ import { resolve } from 'node:path';
 const verificationService = readFileSync(resolve(process.cwd(), 'src/inspection-verifications/inspection-verifications.service.ts'), 'utf8');
 const evidenceService = readFileSync(resolve(process.cwd(), 'src/inspection-findings/inspection-evidence.service.ts'), 'utf8');
 const closingService = readFileSync(resolve(process.cwd(), 'src/inspection-closing/inspection-closing.service.ts'), 'utf8');
+const lifecycleService = readFileSync(resolve(process.cwd(), 'src/inspection-visits/inspection-visit-lifecycle.service.ts'), 'utf8');
 const findingsService = readFileSync(resolve(process.cwd(), 'src/inspection-findings/inspection-findings.service.ts'), 'utf8');
 const migration = readFileSync(resolve(process.cwd(), 'src/database/migrations/1788199200000-phase-d5-3-17-verification-execution.ts'), 'utf8');
 
@@ -33,10 +34,12 @@ test('D5.3.17 links verification photos to the verification visit', () => {
   assert.match(evidenceService, /INSPECTION_VERIFICATION_PHOTO_REQUIRED/);
 });
 
-test('D5.3.17 closes a verification act only after every linked finding has a result', () => {
-  assert.match(closingService, /INSPECTION_VERIFICATION_RESULTS_REQUIRED/);
-  assert.match(closingService, /verificationResults/);
-  assert.match(closingService, /DH-ACT-CLOSURE-V2/);
+test('F4 requires every linked verification result before closing the inspection, not before locking one act', () => {
+  assert.doesNotMatch(closingService, /assertVerificationResultsComplete/);
+  assert.match(lifecycleService, /assertVerificationResultsComplete\(manager, id\)/);
+  assert.match(lifecycleService, /INSPECTION_VERIFICATION_RESULTS_REQUIRED/);
+  assert.match(lifecycleService, /FROM inspection_finding_verification_visits/);
+  assert.match(lifecycleService, /WHERE visit_id=\$1/);
 });
 
 test('D5.3.17 moves verified conforming findings into an office ready-to-close queue', () => {

From 0e2b524a26f5aee6dd36bf7c22e0c8bdf0d560aa Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:08:58 -0300
Subject: [PATCH 166/224] test: lock F4 multi-act lifecycle invariants

---
 .../test/unit/f4-multi-act-lifecycle.test.ts  | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 api-v3/test/unit/f4-multi-act-lifecycle.test.ts

diff --git a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
new file mode 100644
index 0000000..29594ce
--- /dev/null
+++ b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = process.cwd();
+const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
+
+const closing = read('src/inspection-closing/inspection-closing.service.ts');
+const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
+const actEntity = read('src/database/entities/inspection-act.entity.ts');
+
+test('F4 keeps finalized acts irreversible', () => {
+  const reopenBody = closing.slice(closing.indexOf('  async reopen('), closing.indexOf('  async signInspector('));
+  assert.match(reopenBody, /INSPECTION_ACT_LOCK_IS_IMMUTABLE/);
+  assert.match(reopenBody, /throw new ConflictException/);
+  assert.doesNotMatch(reopenBody, /UPDATE inspection_acts/);
+  assert.doesNotMatch(reopenBody, /InspectionActStatus\.DRAFT/);
+});
+
+test('F4 permits multiple acts per inspection but only one simultaneous draft', () => {
+  assert.match(actEntity, /uq_inspection_acts_one_draft_per_visit/);
+  assert.match(actEntity, /where: "status = 'DRAFT'"/);
+  assert.doesNotMatch(actEntity, /uq_inspection_acts_visit['"]/);
+});
+
+test('F4 act locking is independent from inspection-wide verification completion', () => {
+  const prepareBody = closing.slice(closing.indexOf('  async prepare('), closing.indexOf('  async reopen('));
+  assert.doesNotMatch(prepareBody, /inspection_finding_verification_visits/);
+  assert.doesNotMatch(prepareBody, /INSPECTION_VERIFICATION_RESULTS_REQUIRED/);
+  assert.match(prepareBody, /status='LOCKED'/);
+});
+
+test('F4 inspection close is the aggregate gate for sealed acts and verification results', () => {
+  const closeBody = lifecycle.slice(lifecycle.indexOf('  async close('), lifecycle.indexOf('  async cancel('));
+  assert.match(closeBody, /status<>'CANCELLED'/);
+  assert.match(closeBody, /act\.status !== 'SEALED'/);
+  assert.match(closeBody, /INSPECTION_ACTS_NOT_SEALED/);
+  assert.match(closeBody, /assertVerificationResultsComplete\(manager, id\)/);
+  assert.match(closeBody, /InspectionVisitStatus\.CLOSED/);
+});
+
+test('F4 prevents cancelling an inspection that already has a sealed act', () => {
+  const cancelBody = lifecycle.slice(lifecycle.indexOf('  async cancel('), lifecycle.indexOf('  private async lockVisit('));
+  assert.match(cancelBody, /status='SEALED'/);
+  assert.match(cancelBody, /INSPECTION_WITH_SEALED_ACT_CANNOT_CANCEL/);
+});

From 90851e6e7d758d54970a09d69557f2f08e3c5df1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:11:40 -0300
Subject: [PATCH 167/224] test: preserve D5 guarantees under F4 document
 workflow

---
 .../unit/phase-d5-6-phase-d-closure.test.ts   | 51 ++++++++++++-------
 1 file changed, 32 insertions(+), 19 deletions(-)

diff --git a/api-v3/test/unit/phase-d5-6-phase-d-closure.test.ts b/api-v3/test/unit/phase-d5-6-phase-d-closure.test.ts
index 361e6d5..424f7f2 100644
--- a/api-v3/test/unit/phase-d5-6-phase-d-closure.test.ts
+++ b/api-v3/test/unit/phase-d5-6-phase-d-closure.test.ts
@@ -6,13 +6,16 @@ import test from 'node:test';
 const root = process.cwd();
 const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
 
-test('D5.6 immutable act closure remains intact after the multi-act transition', () => {
+test('D5.6 immutable act closure survives F4 as LOCKED then SEALED', () => {
   const acts = read('src/inspection-acts/inspection-acts.service.ts');
   const closing = read('src/inspection-closing/inspection-closing.service.ts');
   assert.match(acts, /INSPECTION_VISIT_DRAFT_ACT_ALREADY_EXISTS/);
-  assert.match(closing, /final_snapshot = \$2/);
-  assert.match(closing, /final_sha256 = \$3/);
-  assert.match(closing, /InspectionActVersionEvent\.CLOSED/);
+  assert.match(closing, /status='LOCKED'/);
+  assert.match(closing, /final_snapshot=\$2/);
+  assert.match(closing, /final_sha256=\$3/);
+  assert.match(closing, /status='SEALED'/);
+  assert.match(closing, /InspectionActVersionEvent\.SEALED/);
+  assert.match(closing, /INSPECTION_ACT_LOCK_IS_IMMUTABLE/);
 });
 
 test('D5.6 preserves findings responses evidence and verification history as non destructive follow-up', () => {
@@ -36,17 +39,20 @@ test('D5.6 keeps Inventory temporal context and contextual finding applicability
   assert.match(findings, /finding_catalog_asset_overrides/);
 });
 
-test('D5.6 preserves reviewed web planning and APK only visit start', () => {
+test('F4 preserves reviewed web planning and APK-only inspection execution', () => {
   const visits = read('src/inspection-visits/inspection-visits.service.ts');
+  const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
   const policy = read('src/inspection-operations/mobile-inspector-policy.ts');
   assert.match(visits, /INSPECTION_CHECKLIST_REQUIRED/);
   assert.match(visits, /inspection_visit_checklist_items/);
-  assert.match(visits, /assertMobileInspector\(principal\)/);
+  assert.match(lifecycle, /async start\(/);
+  assert.match(lifecycle, /assertMobileInspector\(principal\)/);
+  assert.match(lifecycle, /async close\(/);
   assert.match(policy, /transport !== 'bearer'/);
   assert.match(policy, /includes\('inspector'\)/);
 });
 
-test('D5.6 closes the act then freezes the report and produces its Word artifact', () => {
+test('D5.6 report generation remains attached to sealing each act', () => {
   const closing = read('src/inspection-closing/inspection-closing.service.ts');
   const word = read('src/inspection-reports/inspection-report-word.service.ts');
   assert.match(closing, /ensureFrozenReport\(manager, actId, principal, request\)/);
@@ -55,27 +61,34 @@ test('D5.6 closes the act then freezes the report and produces its Word artifact
   assert.match(word, /inspection_report_revisions/);
 });
 
-test('D5.6 leaves report revision approval and final signature exclusively under Director validation', () => {
-  const review = read('src/inspection-reports/inspection-report-review.service.ts');
-  assert.match(review, /await this\.assertDirector\(principal\.userId/);
-  assert.match(review, /review_status = 'APPROVED'/);
-  assert.match(review, /INSPECTION_REPORT_NOT_APPROVED/);
-  assert.match(review, /inspection_report_signatures/);
-  assert.match(review, /Director de Hidrocarburos/);
+test('F4 replaces Director approval with editable INF then immutable GEDO IF officialization', () => {
+  const removedDirectorReview = path.join(root, 'src/inspection-reports/inspection-report-review.service.ts');
+  const workflow = read('src/inspection-reports/inspection-report-workflow.service.ts');
+  assert.equal(fs.existsSync(removedDirectorReview), false);
+  assert.match(workflow, /InspectionReportStatus\.WORKING/);
+  assert.match(workflow, /status='OFFICIALIZED'/);
+  assert.match(workflow, /gedo_if_identifier/);
+  assert.match(workflow, /INSPECTION_REPORT_ALREADY_OFFICIALIZED/);
+  assert.doesNotMatch(workflow, /Director de Hidrocarburos/);
 });
 
-test('D5.6 preserves auditable document delivery while allowing SMTP to remain pending', () => {
+test('F4 keeps auditable delivery, removes Director recipient and makes SMTP administrable', () => {
   const delivery = read('src/inspection-reports/inspection-document-delivery.service.ts');
   const smtp = read('src/inspection-reports/smtp-delivery.service.ts');
-  assert.match(delivery, /WAITING_TRANSPORT/);
   assert.match(delivery, /ACT_PDF/);
   assert.match(delivery, /REPORT_WORD/);
-  assert.match(smtp, /SMTP_HOST/);
-  assert.match(smtp, /MAIL_FROM/);
+  assert.match(delivery, /recipient_kind<>'DIRECTOR'/);
+  assert.match(delivery, /'COMPANY' \| 'OFFICE' \| 'INSPECTOR'/);
+  assert.match(smtp, /system_smtp_settings/);
+  assert.match(smtp, /async saveSettings/);
+  assert.match(smtp, /source:'DATABASE'/);
+  assert.match(smtp, /resolveEnvironment/);
+  assert.match(smtp, /SMTP_SETTINGS_MASTER_KEY/);
 });
 
-test('D5.6 remains a historical closure baseline while Phase F introduces an explicit new migration', () => {
+test('D5.6 remains a historical closure baseline while Phase F introduces explicit migrations', () => {
   const migrations = fs.readdirSync(path.join(root, 'src/database/migrations'));
   assert.equal(migrations.some((name) => /phase-d5-6/i.test(name)), false);
   assert.equal(migrations.some((name) => /phase-f1-1-multi-act-inspections/i.test(name)), true);
+  assert.equal(migrations.some((name) => /f4-/i.test(name)), true);
 });

From 28ec0027101c9b370765fa9303e267daf7d8130a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:15:06 -0300
Subject: [PATCH 168/224] test: retire Director review contract under F4

---
 ...ase-d5-3-22-director-report-review.test.ts | 86 +++++++++++--------
 1 file changed, 48 insertions(+), 38 deletions(-)

diff --git a/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts b/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts
index 4b95d1c..2b40f87 100644
--- a/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts
+++ b/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts
@@ -1,56 +1,66 @@
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
 import test from 'node:test';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
-const read = (path: string) => readFileSync(resolve(process.cwd(), path), 'utf8');
-const migration = read('src/database/migrations/1788631200000-phase-d5-3-22-director-report-review.ts');
-const review = read('src/inspection-reports/inspection-report-review.service.ts');
-const controller = read('src/inspection-reports/inspection-report-review.controller.ts');
-const word = read('src/inspection-reports/inspection-report-word.service.ts');
+const root = process.cwd();
+const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
+
+const legacyMigration = read('src/database/migrations/1788631200000-phase-d5-3-22-director-report-review.ts');
+const f4Removal = read('src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts');
+const workflow = read('src/inspection-reports/inspection-report-workflow.service.ts');
+const officializeDto = read('src/inspection-reports/dto/officialize-inspection-report.dto.ts');
+const delivery = read('src/inspection-reports/inspection-document-delivery.service.ts');
 const acts = read('src/inspection-acts/inspection-acts.service.ts');
 const findings = read('src/inspection-findings/inspection-findings.service.ts');
 
-test('D5.3.22 keeps report corrections as immutable numbered Word revisions', () => {
-  assert.match(migration, /inspection_report_revisions/);
-  assert.match(migration, /UNIQUE \(report_id, revision_number\)/);
-  assert.match(migration, /source IN \('AUTO','DIRECTOR_UPLOAD'\)/);
-  assert.match(word, /'AUTO'/);
-  assert.match(review, /'DIRECTOR_UPLOAD'/);
-  assert.match(review, /current_revision_number = \$2/);
+test('D5.3.22 revision ledger is retained as historical INF versioning', () => {
+  assert.match(legacyMigration, /inspection_report_revisions/);
+  assert.match(legacyMigration, /UNIQUE \(report_id, revision_number\)/);
+  assert.match(legacyMigration, /current_revision_number/);
+  assert.match(workflow, /inspection_report_revisions/);
+  assert.match(workflow, /current_revision_number/);
 });
 
-test('D5.3.22 reserves revision approval and final signature to the Director role', () => {
-  assert.match(migration, /inspection_reports\.revise/);
-  assert.match(migration, /inspection_reports\.review/);
-  assert.match(migration, /inspection_reports\.sign_final/);
-  assert.match(migration, /\('director', 'inspection_reports\.sign_final'\)/);
-  assert.doesNotMatch(migration, /\('admin', 'inspection_reports\.sign_final'\)/);
-  assert.match(review, /role\.code = 'director'/);
-  assert.match(controller, /@RequirePermissions\('inspection_reports\.sign_final'\)/);
+test('F4 explicitly retires Director review approval and final-signature state', () => {
+  assert.match(f4Removal, /DELETE FROM inspection_document_deliveries/);
+  assert.match(f4Removal, /recipient_kind = 'DIRECTOR'/);
+  assert.match(f4Removal, /DROP COLUMN IF EXISTS approved_revision_id/);
+  assert.match(f4Removal, /DROP COLUMN IF EXISTS approved_by/);
+  assert.match(f4Removal, /DROP COLUMN IF EXISTS approved_at/);
+  assert.match(f4Removal, /DROP COLUMN IF EXISTS review_note/);
+  assert.match(f4Removal, /DROP COLUMN IF EXISTS signed_at/);
+  assert.match(f4Removal, /DROP COLUMN IF EXISTS review_status/);
+  assert.doesNotMatch(f4Removal, /DROP COLUMN IF EXISTS current_revision_number/);
 });
 
-test('D5.3.22 approves exactly the latest revision before allowing a final signature', () => {
-  assert.match(review, /revision_number = \$2/);
-  assert.match(review, /approved_revision_id = \$2/);
-  assert.match(review, /review_status = 'APPROVED'/);
-  assert.match(review, /INSPECTION_REPORT_NOT_APPROVED/);
-  assert.match(review, /review_status = 'SIGNED'/);
+test('F4 removes the active Director review service and controller', () => {
+  assert.equal(fs.existsSync(path.join(root, 'src/inspection-reports/inspection-report-review.service.ts')), false);
+  assert.equal(fs.existsSync(path.join(root, 'src/inspection-reports/inspection-report-review.controller.ts')), false);
 });
 
-test('D5.3.22 binds the final Director signature to report and revision hashes', () => {
-  assert.match(migration, /inspection_report_signatures/);
-  assert.match(review, /DH-INSPECTION-REPORT-SIGNATURE-V1/);
-  assert.match(review, /reportFrozenSha256/);
-  assert.match(review, /revisionSha256/);
-  assert.match(review, /sha256CanonicalJson\(payload\)/);
-  assert.match(review, /INSPECTION_REPORT_ALREADY_SIGNED/);
+test('F4 replaces Director approval with editable INF then immutable GEDO IF officialization', () => {
+  assert.match(workflow, /InspectionReportStatus\.WORKING/);
+  assert.match(workflow, /status='OFFICIALIZED'/);
+  assert.match(workflow, /gedo_if_identifier/);
+  assert.match(workflow, /gedo_officialized_at/);
+  assert.match(workflow, /INSPECTION_REPORT_ALREADY_OFFICIALIZED/);
+  assert.match(officializeDto, /gedoIfIdentifier!/);
+  assert.match(officializeDto, /gedoOfficializedAt!/);
+  assert.match(officializeDto, /@MinLength\(2\)/);
+  assert.match(officializeDto, /@IsISO8601/);
 });
 
-test('D5.3.22 changes only the report review layer and preserves inspection immutability', () => {
+test('F4 delivery has no Director recipient while preserving company office and inspector copies', () => {
+  assert.match(delivery, /'COMPANY' \| 'OFFICE' \| 'INSPECTOR'/);
+  assert.match(delivery, /recipient_kind<>'DIRECTOR'/);
+  assert.doesNotMatch(delivery, /recipientKind:'DIRECTOR'/);
+});
+
+test('F4 document workflow changes do not reopen acts or mutate finding history', () => {
   assert.match(acts, /assertVisitHasNoDraftAct/);
   assert.match(acts, /INSPECTION_VISIT_DRAFT_ACT_ALREADY_EXISTS/);
   assert.match(findings, /INSPECTION_FINDING_RESPONSE_IMMUTABLE/);
-  assert.doesNotMatch(migration, /ALTER TABLE inspection_acts/);
-  assert.doesNotMatch(migration, /ALTER TABLE inspection_findings/);
+  assert.doesNotMatch(f4Removal, /ALTER TABLE inspection_acts/);
+  assert.doesNotMatch(f4Removal, /ALTER TABLE inspection_findings/);
 });

From c11808f5603630af4f7b21fb555422e102a3b649 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:15:26 -0300
Subject: [PATCH 169/224] test: align automatic report contract with F4 sealing

---
 .../unit/phase-d5-3-20-automatic-word-report.test.ts   | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts b/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts
index 9a9b157..fd6b2d9 100644
--- a/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts
+++ b/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts
@@ -11,14 +11,15 @@ const controller = read('src/inspection-reports/inspection-reports.controller.ts
 const builder = read('src/inspection-reports/inspection-report-word-builder.ts');
 const wordService = read('src/inspection-reports/inspection-report-word.service.ts');
 
-test('D5.3.20 freezes one report automatically in the same act-closing transaction', () => {
+test('D5.3.20/F4 freezes one report from each sealed act and generates its Word artifact', () => {
   assert.match(closing, /await this\.reports\.ensureFrozenReport\(manager, actId, principal, request\)/);
   assert.match(closing, /await this\.reports\.ensureWordForAct\(actId\)/);
   assert.match(reports, /async ensureFrozenReport\(/);
   assert.match(reports, /SELECT id FROM inspection_reports WHERE act_id/);
+  assert.match(reports, /act\.status = 'SEALED'/);
 });
 
-test('D5.3.20 stores an integrity-checked Word artifact without changing the frozen report', () => {
+test('D5.3.20 stores an integrity-checked Word artifact without changing the frozen source snapshot', () => {
   assert.match(migration, /ADD COLUMN word_status varchar\(24\)/);
   assert.match(migration, /word_sha256 char\(64\)/);
   assert.match(migration, /word_generated_at timestamptz/);
@@ -35,7 +36,8 @@ test('D5.3.20 builds OOXML Word from the frozen act snapshot without external do
   assert.doesNotMatch(builder, /nodemailer|libreoffice|pandoc/i);
 });
 
-test('D5.3.20 keeps frozen report generation act-scoped and leaves email delivery for a configured phase', () => {
-  assert.match(closing, /findingsRemainOpen: true/);
+test('F4 keeps report generation act-scoped while findings and inspection lifecycle remain independent', () => {
+  assert.match(closing, /findingsRemainIndependent: true/);
+  assert.match(closing, /inspectionRemainsIndependent: true/);
   assert.doesNotMatch(migration, /smtp|email_outbox|mail_delivery/i);
 });

From 2018e1aeba8fb16f9d2e8e7c0784c1deda84dc0b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:15:44 -0300
Subject: [PATCH 170/224] test: align document delivery contract with F4
 recipients and SMTP

---
 .../phase-d5-3-21-document-delivery.test.ts   | 71 +++++++++++++++++--
 1 file changed, 64 insertions(+), 7 deletions(-)

diff --git a/api-v3/test/unit/phase-d5-3-21-document-delivery.test.ts b/api-v3/test/unit/phase-d5-3-21-document-delivery.test.ts
index 43bbdac..f5fc184 100644
--- a/api-v3/test/unit/phase-d5-3-21-document-delivery.test.ts
+++ b/api-v3/test/unit/phase-d5-3-21-document-delivery.test.ts
@@ -1,7 +1,64 @@
-import assert from 'node:assert/strict'; import test from 'node:test'; import {readFileSync} from 'node:fs'; import {resolve} from 'node:path';
-const read=(path:string)=>readFileSync(resolve(process.cwd(),path),'utf8'); const migration=read('src/database/migrations/1788544800000-phase-d5-3-21-document-delivery.ts'); const delivery=read('src/inspection-reports/inspection-document-delivery.service.ts'); const smtp=read('src/inspection-reports/smtp-delivery.service.ts'); const pdf=read('src/inspection-reports/inspection-act-pdf-builder.ts'); const controller=read('src/inspection-reports/document-delivery.controller.ts'); const reports=read('src/inspection-reports/inspection-reports.service.ts');
-test('D5.3.21 stores institutional and company recipients without hardcoding addresses',()=>{assert.match(migration,/institutional_delivery_settings/);assert.match(migration,/notification_email varchar\(320\)/);assert.match(delivery,/office_email/);assert.match(delivery,/director_email/);assert.doesNotMatch(delivery,/@gmail\.com|@hotmail\.com|@mendoza\.gov/i);});
-test('D5.3.21 creates an immutable act PDF and separates its delivery from the report Word',()=>{assert.match(migration,/inspection_act_pdf_artifacts/);assert.match(migration,/ACT_PDF/);assert.match(migration,/REPORT_WORD/);assert.match(pdf,/%PDF-1\.4/);assert.match(delivery,/this\.pdf\.ensure/);assert.match(delivery,/this\.word\.ensure/);});
-test('D5.3.21 keeps an auditable retryable outbox with explicit waiting states',()=>{assert.match(migration,/WAITING_RECIPIENT/);assert.match(migration,/WAITING_TRANSPORT/);assert.match(migration,/WAITING_ARTIFACT/);assert.match(delivery,/export interface DeliveryRow/);assert.match(controller,/Promise<DeliveryRow>/);assert.match(controller,/outbox\/:id\/retry/);assert.match(controller,/retry-pending/);});
-test('D5.3.21 only attempts SMTP when transport and recipients are configured',()=>{assert.match(smtp,/SMTP_HOST/);assert.match(smtp,/MAIL_FROM/);assert.match(smtp,/STARTTLS/);assert.match(delivery,/this\.smtp\.configured\(\)/);assert.match(delivery,/WAITING_TRANSPORT/);});
-test('D5.3.21 delivery stays act-scoped after F1.1 enables multiple acts',()=>{assert.match(reports,/await this\.delivery\.dispatchForAct\(actId\)/); const acts=read('src/inspection-acts/inspection-acts.service.ts');assert.match(acts,/assertVisitHasNoDraftAct/);assert.match(acts,/INSPECTION_VISIT_DRAFT_ACT_ALREADY_EXISTS/);});
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const read = (path: string) => readFileSync(resolve(process.cwd(), path), 'utf8');
+const migration = read('src/database/migrations/1788544800000-phase-d5-3-21-document-delivery.ts');
+const f4DirectorRemoval = read('src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts');
+const delivery = read('src/inspection-reports/inspection-document-delivery.service.ts');
+const smtp = read('src/inspection-reports/smtp-delivery.service.ts');
+const pdf = read('src/inspection-reports/inspection-act-pdf-builder.ts');
+const controller = read('src/inspection-reports/document-delivery.controller.ts');
+const reports = read('src/inspection-reports/inspection-reports.service.ts');
+
+test('D5.3.21/F4 stores configurable recipients without hardcoding addresses and retires Director delivery', () => {
+  assert.match(migration, /institutional_delivery_settings/);
+  assert.match(migration, /notification_email varchar\(320\)/);
+  assert.match(delivery, /office_email/);
+  assert.match(delivery, /'COMPANY' \| 'OFFICE' \| 'INSPECTOR'/);
+  assert.match(delivery, /recipient_kind<>'DIRECTOR'/);
+  assert.match(f4DirectorRemoval, /DELETE FROM inspection_document_deliveries/);
+  assert.match(f4DirectorRemoval, /recipient_kind = 'DIRECTOR'/);
+  assert.doesNotMatch(delivery, /@gmail\.com|@hotmail\.com|@mendoza\.gov/i);
+});
+
+test('D5.3.21 creates an immutable act PDF and separates its delivery from the editable INF Word', () => {
+  assert.match(migration, /inspection_act_pdf_artifacts/);
+  assert.match(migration, /ACT_PDF/);
+  assert.match(migration, /REPORT_WORD/);
+  assert.match(pdf, /%PDF-1\.4/);
+  assert.match(delivery, /this\.pdf\.ensure/);
+  assert.match(delivery, /this\.word\.ensure/);
+  assert.match(delivery, /INF editable/);
+});
+
+test('D5.3.21 keeps an auditable retryable outbox with explicit waiting states', () => {
+  assert.match(migration, /WAITING_RECIPIENT/);
+  assert.match(migration, /WAITING_TRANSPORT/);
+  assert.match(migration, /WAITING_ARTIFACT/);
+  assert.match(delivery, /export interface DeliveryRow/);
+  assert.match(controller, /Promise<DeliveryRow>/);
+  assert.match(controller, /outbox\/:id\/retry/);
+  assert.match(controller, /retry-pending/);
+});
+
+test('F4 SMTP can be administered in database while retaining environment fallback', () => {
+  assert.match(smtp, /system_smtp_settings/);
+  assert.match(smtp, /async saveSettings/);
+  assert.match(smtp, /source:'DATABASE'/);
+  assert.match(smtp, /resolveEnvironment/);
+  assert.match(smtp, /SMTP_HOST/);
+  assert.match(smtp, /MAIL_FROM/);
+  assert.match(smtp, /STARTTLS/);
+  assert.match(smtp, /SMTP_SETTINGS_MASTER_KEY/);
+  assert.match(delivery, /await this\.smtp\.configured\(\)/);
+  assert.match(delivery, /WAITING_TRANSPORT/);
+});
+
+test('D5.3.21/F4 delivery stays act-scoped after multiple acts per inspection', () => {
+  assert.match(reports, /await this\.delivery\.dispatchForAct\(actId\)/);
+  const acts = read('src/inspection-acts/inspection-acts.service.ts');
+  assert.match(acts, /assertVisitHasNoDraftAct/);
+  assert.match(acts, /INSPECTION_VISIT_DRAFT_ACT_ALREADY_EXISTS/);
+});

From 38742bf140741ba56499c698105ec1961ed8f643 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:16:23 -0300
Subject: [PATCH 171/224] test: align mobile multi-act lifecycle with F4
 sealing

---
 .../test/unit/f3-2-mobile-multi-acta.test.ts  | 22 ++++++++++++-------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts b/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts
index 297b136..084934b 100644
--- a/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts
+++ b/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts
@@ -4,7 +4,7 @@ import test from 'node:test';
 
 const read = (path: string) => readFileSync(path, 'utf8');
 
-test('F3.2 mantiene múltiples Actas con un solo borrador simultáneo por inspección', () => {
+test('F3.2/F4 mantiene múltiples Actas con un solo borrador simultáneo por inspección', () => {
   const migration = read('src/database/migrations/1789495200000-phase-f1-1-multi-act-inspections.ts');
   assert.match(migration, /DROP CONSTRAINT IF EXISTS uq_inspection_acts_visit/);
   assert.match(migration, /CREATE UNIQUE INDEX uq_inspection_acts_one_draft_per_visit/);
@@ -24,19 +24,25 @@ test('F3.2 permite seleccionar el Acta explícitamente al trabajar Hallazgos des
   assert.match(service, /FIELD_FINDING_ASSET_NOT_IN_ACT/);
 });
 
-test('F3.2 conserva el cierre documental inmutable de cada Acta', () => {
+test('F4 conserva el cierre documental inmutable de cada Acta como LOCKED y luego SEALED', () => {
   const closing = read('src/inspection-closing/inspection-closing.service.ts');
+  assert.match(closing, /status='LOCKED'/);
   assert.match(closing, /INSPECTION_ACT_INSPECTOR_SIGNATURE_REQUIRED/);
   assert.match(closing, /INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED/);
   assert.match(closing, /finalSha256 = sha256CanonicalJson\(finalSnapshot\)/);
-  assert.match(closing, /status = 'CLOSED'/);
+  assert.match(closing, /status='SEALED'/);
+  assert.match(closing, /INSPECTION_ACT_LOCK_IS_IMMUTABLE/);
   assert.match(closing, /ensureFrozenReport/);
   assert.match(closing, /ensureWordForAct/);
 });
 
-test('F3.2 cierra la inspección sólo cuando no quedan borradores ni Actas sin firma de inspector', () => {
-  const visits = read('src/inspection-visits/inspection-visits.service.ts');
-  assert.match(visits, /INSPECTION_VISIT_DRAFT_ACTS_PENDING/);
-  assert.match(visits, /INSPECTION_VISIT_INSPECTOR_SIGNATURE_PENDING/);
-  assert.match(visits, /actsMayCompleteCompanySignatureLater: true/);
+test('F4 cierra la inspección sólo cuando todas las Actas no canceladas están selladas y las verificaciones resueltas', () => {
+  const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
+  const closeBody = lifecycle.slice(lifecycle.indexOf('  async close('), lifecycle.indexOf('  async cancel('));
+  assert.match(closeBody, /INSPECTION_REQUIRES_ACT/);
+  assert.match(closeBody, /INSPECTION_ACTS_NOT_SEALED/);
+  assert.match(closeBody, /act\.status !== 'SEALED'/);
+  assert.match(closeBody, /assertVerificationResultsComplete\(manager, id\)/);
+  assert.match(closeBody, /visit\.status = InspectionVisitStatus\.CLOSED/);
+  assert.doesNotMatch(closeBody, /actsMayCompleteCompanySignatureLater/);
 });

From 9fab773090bae6c16598d737e427fdc2e0d70d8f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:17:30 -0300
Subject: [PATCH 172/224] test: assert Survey execution authorization is
 retired in F4

---
 .../survey-execution-authorization.test.ts    | 32 +++++++++++--------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/api-v3/test/unit/survey-execution-authorization.test.ts b/api-v3/test/unit/survey-execution-authorization.test.ts
index 9a7f7c4..59be86c 100644
--- a/api-v3/test/unit/survey-execution-authorization.test.ts
+++ b/api-v3/test/unit/survey-execution-authorization.test.ts
@@ -1,18 +1,24 @@
-import 'reflect-metadata';
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
 import test from 'node:test';
-import { REQUIRED_PERMISSIONS_KEY } from '../../src/authorization/decorators/require-permissions.decorator';
-import { SurveyExecutionController } from '../../src/survey-execution/survey-execution.controller';
 
-function permissionFor(method: string): string[] {
-  const controller = SurveyExecutionController.prototype;
-  const handler = controller[method as keyof typeof controller];
-  return Reflect.getMetadata(REQUIRED_PERMISSIONS_KEY, handler) as string[];
-}
+const root = process.cwd();
+const migration = fs.readFileSync(
+  path.join(root, 'src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts'),
+  'utf8',
+);
 
-test('survey report endpoints separate reading, capture and review', () => {
-  assert.deepEqual(permissionFor('get'), ['surveys.read_reports']);
-  assert.deepEqual(permissionFor('save'), ['surveys.capture']);
-  assert.deepEqual(permissionFor('submit'), ['surveys.capture']);
-  assert.deepEqual(permissionFor('review'), ['surveys.review']);
+test('F4 removes the Survey execution controller from the active API', () => {
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-execution/survey-execution.controller.ts')), false);
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-execution/survey-execution.service.ts')), false);
+});
+
+test('F4 removes Survey execution and review permissions from active authorization', () => {
+  assert.match(migration, /'surveys\.execute'/);
+  assert.match(migration, /'surveys\.read_reports'/);
+  assert.match(migration, /'surveys\.capture'/);
+  assert.match(migration, /'surveys\.review'/);
+  assert.match(migration, /DELETE FROM role_permissions/);
+  assert.match(migration, /DELETE FROM permissions/);
 });

From 792e21e669e80cff6a557bcf89e845a5d6294e4d Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:17:48 -0300
Subject: [PATCH 173/224] test: assert Survey execution DTOs are retired in F4

---
 api-v3/test/unit/survey-execution-dto.test.ts | 60 +++++++------------
 1 file changed, 21 insertions(+), 39 deletions(-)

diff --git a/api-v3/test/unit/survey-execution-dto.test.ts b/api-v3/test/unit/survey-execution-dto.test.ts
index fa7a655..06ec6fe 100644
--- a/api-v3/test/unit/survey-execution-dto.test.ts
+++ b/api-v3/test/unit/survey-execution-dto.test.ts
@@ -1,48 +1,30 @@
-import 'reflect-metadata';
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
 import test from 'node:test';
-import { validate } from 'class-validator';
-import { ReviewSurveyReportDto } from '../../src/survey-execution/dto/review-survey-report.dto';
-import { SaveSurveyReportDto } from '../../src/survey-execution/dto/save-survey-report.dto';
 
-const MEDIA_ID = '16e54e65-60cf-4739-b0d1-ccdd904fbfd5';
+const root = process.cwd();
+const migration = fs.readFileSync(
+  path.join(root, 'src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts'),
+  'utf8',
+);
 
-test('field report DTO accepts outcome, GPS and protected media references', async () => {
-  const dto = Object.assign(new SaveSurveyReportDto(), {
-    outcome: 'CONFIRMED',
-    observedAt: '2026-08-14T18:00:00.000Z',
-    latitude: -32.8895,
-    longitude: -68.8458,
-    accuracyM: 4.25,
-    notes: 'Activo verificado en campo.',
-    mediaIds: [MEDIA_ID],
-  });
-  assert.deepEqual(await validate(dto), []);
+test('F4 removes Survey execution DTOs together with the retired endpoint surface', () => {
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-execution/dto/save-survey-report.dto.ts')), false);
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-execution/dto/review-survey-report.dto.ts')), false);
 });
 
-test('field report DTO rejects invalid coordinates and repeated evidence', async () => {
-  const dto = Object.assign(new SaveSurveyReportDto(), {
-    outcome: 'CONFIRMED',
-    observedAt: 'not-a-date',
-    latitude: -95,
-    longitude: -68.8458,
-    accuracyM: 4.25,
-    mediaIds: [MEDIA_ID, MEDIA_ID],
-  });
-  const properties = new Set((await validate(dto)).map((error) => error.property));
-  assert.equal(properties.has('observedAt'), true);
-  assert.equal(properties.has('latitude'), true);
-  assert.equal(properties.has('mediaIds'), true);
+test('F4 drops Survey report tables without CASCADE so unexpected dependencies stop migration', () => {
+  assert.match(migration, /DROP TABLE IF EXISTS survey_target_report_versions/);
+  assert.match(migration, /DROP TABLE IF EXISTS survey_target_report_media/);
+  assert.match(migration, /DROP TABLE IF EXISTS survey_target_reports/);
+  assert.doesNotMatch(migration, /DROP TABLE IF EXISTS survey_target_reports CASCADE/);
 });
 
-test('review DTO only accepts explicit approval or rejection decisions', async () => {
-  const dto = Object.assign(new ReviewSurveyReportDto(), {
-    decision: 'APPROVE',
-    notes: null,
-  });
-  assert.deepEqual(await validate(dto), []);
-
-  dto.decision = 'MAYBE' as typeof dto.decision;
-  const properties = new Set((await validate(dto)).map((error) => error.property));
-  assert.equal(properties.has('decision'), true);
+test('F4 rollback can reconstruct the historical Survey report integrity rules', () => {
+  assert.match(migration, /CREATE TABLE IF NOT EXISTS survey_target_reports/);
+  assert.match(migration, /outcome IN \('CONFIRMED','CHANGES_RECORDED','NOT_LOCATED'\)/);
+  assert.match(migration, /latitude BETWEEN -90 AND 90/);
+  assert.match(migration, /longitude BETWEEN -180 AND 180/);
+  assert.match(migration, /CREATE TABLE IF NOT EXISTS survey_target_report_versions/);
 });

From 248fb6285b3c6c73b739f774a242c49aacf42dbb Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:18:04 -0300
Subject: [PATCH 174/224] test: assert Survey planning authorization is retired
 in F4

---
 .../survey-planning-authorization.test.ts     | 46 +++++++++----------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/api-v3/test/unit/survey-planning-authorization.test.ts b/api-v3/test/unit/survey-planning-authorization.test.ts
index 63949ae..92682a0 100644
--- a/api-v3/test/unit/survey-planning-authorization.test.ts
+++ b/api-v3/test/unit/survey-planning-authorization.test.ts
@@ -1,31 +1,29 @@
-import 'reflect-metadata';
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
 import test from 'node:test';
-import { REQUIRED_PERMISSIONS_KEY } from '../../src/authorization/decorators/require-permissions.decorator';
-import {
-  SurveyCampaignsController,
-  SurveyCampaignTargetsController,
-} from '../../src/survey-planning/survey-campaigns.controller';
 
-function permissionFor(controller: object, method: string): string[] {
-  const handler = controller[method as keyof typeof controller];
-  return Reflect.getMetadata(REQUIRED_PERMISSIONS_KEY, handler) as string[];
-}
+const root = process.cwd();
+const migration = fs.readFileSync(
+  path.join(root, 'src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts'),
+  'utf8',
+);
 
-test('campaign endpoints separate reading, management and assignment', () => {
-  const controller = SurveyCampaignsController.prototype;
-  assert.deepEqual(permissionFor(controller, 'list'), ['surveys.read']);
-  assert.deepEqual(permissionFor(controller, 'get'), ['surveys.read']);
-  assert.deepEqual(permissionFor(controller, 'assignees'), ['surveys.assign']);
-  assert.deepEqual(permissionFor(controller, 'create'), ['surveys.manage']);
-  assert.deepEqual(permissionFor(controller, 'update'), ['surveys.manage']);
-  assert.deepEqual(permissionFor(controller, 'changeStatus'), ['surveys.manage']);
-  assert.deepEqual(permissionFor(controller, 'addTarget'), ['surveys.manage']);
+test('F4 removes Survey planning controllers from the active API', () => {
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-planning/survey-campaigns.controller.ts')), false);
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-planning/survey-campaigns.service.ts')), false);
 });
 
-test('target planning, assignment and execution use distinct permissions', () => {
-  const controller = SurveyCampaignTargetsController.prototype;
-  assert.deepEqual(permissionFor(controller, 'update'), ['surveys.manage']);
-  assert.deepEqual(permissionFor(controller, 'assign'), ['surveys.assign']);
-  assert.deepEqual(permissionFor(controller, 'changeStatus'), ['surveys.execute']);
+test('F4 removes Survey planning permissions and their role bindings', () => {
+  assert.match(migration, /'surveys\.read'/);
+  assert.match(migration, /'surveys\.manage'/);
+  assert.match(migration, /'surveys\.assign'/);
+  assert.match(migration, /DELETE FROM role_permissions/);
+  assert.match(migration, /DELETE FROM permissions/);
+});
+
+test('F4 rollback retains the former role-permission map only as a reversible migration path', () => {
+  assert.match(migration, /const rolePermissionValues/);
+  assert.match(migration, /WITH mapping\(role_code,permission_code\)/);
+  assert.match(migration, /INSERT INTO role_permissions/);
 });

From ad44dc7ef63164980519dac91d705fdac29632af Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:18:19 -0300
Subject: [PATCH 175/224] test: assert Survey planning DTOs are retired in F4

---
 api-v3/test/unit/survey-planning-dto.test.ts | 50 +++++++++-----------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/api-v3/test/unit/survey-planning-dto.test.ts b/api-v3/test/unit/survey-planning-dto.test.ts
index 4df9a52..7bea745 100644
--- a/api-v3/test/unit/survey-planning-dto.test.ts
+++ b/api-v3/test/unit/survey-planning-dto.test.ts
@@ -1,35 +1,31 @@
-import 'reflect-metadata';
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
 import test from 'node:test';
-import { validate } from 'class-validator';
-import { AddSurveyTargetDto } from '../../src/survey-planning/dto/add-survey-target.dto';
-import { CreateSurveyCampaignDto } from '../../src/survey-planning/dto/create-survey-campaign.dto';
 
-const ASSET_ID = '16e54e65-60cf-4739-b0d1-ccdd904fbfd5';
+const root = process.cwd();
+const migration = fs.readFileSync(
+  path.join(root, 'src/database/migrations/1790000300000-f4-remove-survey-subsystem.ts'),
+  'utf8',
+);
 
-test('campaign DTO accepts dynamic asset scope and ISO planning dates', async () => {
-  const dto = Object.assign(new CreateSurveyCampaignDto(), {
-    code: 'REL-2026-001',
-    name: 'Campaña operativa',
-    description: null,
-    plannedStartAt: '2026-08-15T12:00:00.000Z',
-    plannedEndAt: '2026-08-20T12:00:00.000Z',
-    scopeAssetId: ASSET_ID,
-    coordinatorUserId: null,
-  });
-  assert.deepEqual(await validate(dto), []);
+test('F4 removes Survey planning DTOs from the active code surface', () => {
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-planning/dto/create-survey-campaign.dto.ts')), false);
+  assert.equal(fs.existsSync(path.join(root, 'src/survey-planning/dto/add-survey-target.dto.ts')), false);
 });
 
-test('target DTO references an existing Maestro asset instead of copying it', async () => {
-  const dto = Object.assign(new AddSurveyTargetDto(), {
-    assetId: ASSET_ID,
-    assignedUserId: null,
-    dueAt: null,
-    instructions: null,
-  });
-  assert.deepEqual(await validate(dto), []);
+test('F4 drops Survey planning tables after removing their permissions', () => {
+  assert.match(migration, /DELETE FROM permissions/);
+  assert.match(migration, /DROP TABLE IF EXISTS survey_campaign_targets/);
+  assert.match(migration, /DROP TABLE IF EXISTS survey_campaigns/);
+  assert.doesNotMatch(migration, /DROP TABLE IF EXISTS survey_campaigns CASCADE/);
+});
 
-  dto.assetId = 'not-a-uuid';
-  const properties = new Set((await validate(dto)).map((error) => error.property));
-  assert.equal(properties.has('assetId'), true);
+test('F4 rollback can reconstruct historical Survey planning dates and asset references', () => {
+  assert.match(migration, /CREATE TABLE IF NOT EXISTS survey_campaigns/);
+  assert.match(migration, /planned_start_at timestamptz/);
+  assert.match(migration, /planned_end_at timestamptz/);
+  assert.match(migration, /scope_asset_id uuid REFERENCES assets\(id\) ON DELETE RESTRICT/);
+  assert.match(migration, /CREATE TABLE IF NOT EXISTS survey_campaign_targets/);
+  assert.match(migration, /asset_id uuid NOT NULL REFERENCES assets\(id\) ON DELETE RESTRICT/);
 });

From 3a1379d49a5224d343741cac8572066079f8b590 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:20:14 -0300
Subject: [PATCH 176/224] fix: fully retire Director report permissions in F4

---
 ...400000-f4-remove-director-report-legacy.ts | 83 +++++++++++++++++--
 1 file changed, 77 insertions(+), 6 deletions(-)

diff --git a/api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts b/api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts
index da4f54f..96b7ff8 100644
--- a/api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts
+++ b/api-v3/src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts
@@ -1,10 +1,17 @@
 import { MigrationInterface, QueryRunner } from 'typeorm';
 
+const legacyDirectorPermissions = [
+  ['inspection_reports.revise', 'Cargar versiones corregidas del informe para revisión directiva'],
+  ['inspection_reports.review', 'Aprobar la versión vigente del informe'],
+  ['inspection_reports.sign_final', 'Firmar electrónicamente el informe final aprobado'],
+] as const;
+
 /**
- * Retira definitivamente el circuito legacy Director -> revisión -> aprobación -> firma.
+ * Retira definitivamente el circuito activo legacy Director -> revisión -> aprobación -> firma.
  *
- * current_revision_number se conserva porque pertenece al versionado útil del INF y no
- * al circuito de aprobación retirado.
+ * current_revision_number e inspection_report_revisions se conservan porque forman parte del
+ * versionado útil del INF. inspection_report_signatures también se conserva como archivo
+ * histórico: F4 quita sus endpoints/permisos pero no destruye evidencia documental ya emitida.
  */
 export class F4RemoveDirectorReportLegacy1790000400000 implements MigrationInterface {
   name = 'F4RemoveDirectorReportLegacy1790000400000';
@@ -17,6 +24,28 @@ export class F4RemoveDirectorReportLegacy1790000400000 implements MigrationInter
       WHERE recipient_kind = 'DIRECTOR'
     `);
 
+    // Retira permisos huérfanos del circuito anterior para que tampoco aparezcan
+    // como capacidades administrables en RBAC una vez eliminados sus endpoints.
+    await queryRunner.query(`
+      DELETE FROM role_permissions
+      WHERE permission_id IN (
+        SELECT id FROM permissions
+        WHERE code IN (
+          'inspection_reports.revise',
+          'inspection_reports.review',
+          'inspection_reports.sign_final'
+        )
+      )
+    `);
+    await queryRunner.query(`
+      DELETE FROM permissions
+      WHERE code IN (
+        'inspection_reports.revise',
+        'inspection_reports.review',
+        'inspection_reports.sign_final'
+      )
+    `);
+
     await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS approved_revision_id`);
     await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS approved_by`);
     await queryRunner.query(`ALTER TABLE inspection_reports DROP COLUMN IF EXISTS approved_at`);
@@ -26,9 +55,9 @@ export class F4RemoveDirectorReportLegacy1790000400000 implements MigrationInter
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
-    // El rollback reconstruye la forma del esquema, pero no recrea entregas Director
-    // ni datos de aprobación eliminados. El backup PRE-F4 es la fuente de recuperación
-    // si alguna vez fuera necesario volver a ese circuito.
+    // El rollback reconstruye el contrato técnico legacy, pero no recrea entregas Director
+    // ni valores de aprobación eliminados. El backup PRE-F4 sigue siendo la fuente de
+    // recuperación de esos datos históricos si alguna vez fuera necesario volver al circuito.
     await queryRunner.query(`
       ALTER TABLE inspection_reports
       ADD COLUMN IF NOT EXISTS review_status varchar(32) NOT NULL DEFAULT 'PENDING_REVIEW'
@@ -38,5 +67,47 @@ export class F4RemoveDirectorReportLegacy1790000400000 implements MigrationInter
     await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS approved_at timestamptz`);
     await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS review_note varchar(1000)`);
     await queryRunner.query(`ALTER TABLE inspection_reports ADD COLUMN IF NOT EXISTS signed_at timestamptz`);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE inspection_reports
+          ADD CONSTRAINT chk_inspection_reports_review_status
+          CHECK (review_status IN ('PENDING_REVIEW','APPROVED','SIGNED'));
+      EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+    `);
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE inspection_reports
+          ADD CONSTRAINT fk_inspection_reports_approved_by
+          FOREIGN KEY (approved_by) REFERENCES users(id) ON DELETE SET NULL;
+      EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+    `);
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE inspection_reports
+          ADD CONSTRAINT fk_inspection_reports_approved_revision
+          FOREIGN KEY (approved_revision_id) REFERENCES inspection_report_revisions(id) ON DELETE RESTRICT;
+      EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+    `);
+
+    for (const [code, description] of legacyDirectorPermissions) {
+      await queryRunner.query(
+        `INSERT INTO permissions (code, description) VALUES ($1, $2) ON CONFLICT (code) DO UPDATE SET description = EXCLUDED.description`,
+        [code, description],
+      );
+    }
+    await queryRunner.query(`
+      WITH mapping(role_code, permission_code) AS (VALUES
+        ('director', 'inspection_reports.revise'),
+        ('director', 'inspection_reports.review'),
+        ('director', 'inspection_reports.sign_final')
+      )
+      INSERT INTO role_permissions (role_id, permission_id)
+      SELECT role.id, permission.id
+      FROM mapping
+      JOIN roles role ON role.code = mapping.role_code
+      JOIN permissions permission ON permission.code = mapping.permission_code
+      ON CONFLICT (role_id, permission_id) DO NOTHING
+    `);
   }
 }

From 5393a40e8b941c0eefac44465ae5d61934106fa3 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:20:33 -0300
Subject: [PATCH 177/224] test: tighten F4 Director retirement and retained INF
 history

---
 ...ase-d5-3-22-director-report-review.test.ts | 24 ++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts b/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts
index 2b40f87..9893110 100644
--- a/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts
+++ b/api-v3/test/unit/phase-d5-3-22-director-report-review.test.ts
@@ -9,6 +9,7 @@ const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'u
 const legacyMigration = read('src/database/migrations/1788631200000-phase-d5-3-22-director-report-review.ts');
 const f4Removal = read('src/database/migrations/1790000400000-f4-remove-director-report-legacy.ts');
 const workflow = read('src/inspection-reports/inspection-report-workflow.service.ts');
+const word = read('src/inspection-reports/inspection-report-word.service.ts');
 const officializeDto = read('src/inspection-reports/dto/officialize-inspection-report.dto.ts');
 const delivery = read('src/inspection-reports/inspection-document-delivery.service.ts');
 const acts = read('src/inspection-acts/inspection-acts.service.ts');
@@ -18,13 +19,19 @@ test('D5.3.22 revision ledger is retained as historical INF versioning', () => {
   assert.match(legacyMigration, /inspection_report_revisions/);
   assert.match(legacyMigration, /UNIQUE \(report_id, revision_number\)/);
   assert.match(legacyMigration, /current_revision_number/);
-  assert.match(workflow, /inspection_report_revisions/);
-  assert.match(workflow, /current_revision_number/);
+  assert.match(word, /inspection_report_revisions/);
+  assert.match(word, /current_revision_number/);
+  assert.match(word, /'AUTO'/);
 });
 
 test('F4 explicitly retires Director review approval and final-signature state', () => {
   assert.match(f4Removal, /DELETE FROM inspection_document_deliveries/);
   assert.match(f4Removal, /recipient_kind = 'DIRECTOR'/);
+  assert.match(f4Removal, /DELETE FROM role_permissions/);
+  assert.match(f4Removal, /DELETE FROM permissions/);
+  assert.match(f4Removal, /inspection_reports\.revise/);
+  assert.match(f4Removal, /inspection_reports\.review/);
+  assert.match(f4Removal, /inspection_reports\.sign_final/);
   assert.match(f4Removal, /DROP COLUMN IF EXISTS approved_revision_id/);
   assert.match(f4Removal, /DROP COLUMN IF EXISTS approved_by/);
   assert.match(f4Removal, /DROP COLUMN IF EXISTS approved_at/);
@@ -34,9 +41,11 @@ test('F4 explicitly retires Director review approval and final-signature state',
   assert.doesNotMatch(f4Removal, /DROP COLUMN IF EXISTS current_revision_number/);
 });
 
-test('F4 removes the active Director review service and controller', () => {
+test('F4 removes active Director endpoints but preserves historical signature evidence', () => {
   assert.equal(fs.existsSync(path.join(root, 'src/inspection-reports/inspection-report-review.service.ts')), false);
   assert.equal(fs.existsSync(path.join(root, 'src/inspection-reports/inspection-report-review.controller.ts')), false);
+  assert.doesNotMatch(f4Removal, /DROP TABLE IF EXISTS inspection_report_signatures/);
+  assert.match(f4Removal, /inspection_report_signatures también se conserva como archivo/);
 });
 
 test('F4 replaces Director approval with editable INF then immutable GEDO IF officialization', () => {
@@ -57,6 +66,15 @@ test('F4 delivery has no Director recipient while preserving company office and
   assert.doesNotMatch(delivery, /recipientKind:'DIRECTOR'/);
 });
 
+test('F4 Director-retirement rollback reconstructs schema and RBAC contract without inventing deleted data', () => {
+  assert.match(f4Removal, /ADD COLUMN IF NOT EXISTS review_status/);
+  assert.match(f4Removal, /chk_inspection_reports_review_status/);
+  assert.match(f4Removal, /fk_inspection_reports_approved_by/);
+  assert.match(f4Removal, /fk_inspection_reports_approved_revision/);
+  assert.match(f4Removal, /INSERT INTO permissions/);
+  assert.match(f4Removal, /INSERT INTO role_permissions/);
+});
+
 test('F4 document workflow changes do not reopen acts or mutate finding history', () => {
   assert.match(acts, /assertVisitHasNoDraftAct/);
   assert.match(acts, /INSPECTION_VISIT_DRAFT_ACT_ALREADY_EXISTS/);

From 271290abe42c4f6ca7e88505781d01324eb51e44 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:23:55 -0300
Subject: [PATCH 178/224] fix: align F4 document lifecycle database constraints

---
 ...f4-align-document-lifecycle-constraints.ts | 205 ++++++++++++++++++
 1 file changed, 205 insertions(+)
 create mode 100644 api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts

diff --git a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
new file mode 100644
index 0000000..4800de9
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
@@ -0,0 +1,205 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Alinea las restricciones físicas heredadas de D5 con el ciclo documental F4.
+ *
+ * F4 incorpora estados LOCKED/SEALED para Actas y WORKING/OFFICIALIZED para INF.
+ * Las migraciones históricas conservaban CHECKs y triggers de READY/CLOSED/FROZEN,
+ * por lo que el servicio podía compilar pero PostgreSQL rechazaba las transiciones.
+ */
+export class F4AlignDocumentLifecycleConstraints1790000600000 implements MigrationInterface {
+  name = 'F4AlignDocumentLifecycleConstraints1790000600000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE inspection_reports
+      DROP CONSTRAINT IF EXISTS chk_inspection_reports_status
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_reports
+      ADD CONSTRAINT chk_inspection_reports_status CHECK (
+        status IN ('WORKING','OFFICIALIZED','FROZEN','CANCELLED')
+      )
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      DROP CONSTRAINT IF EXISTS chk_inspection_acts_status
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      ADD CONSTRAINT chk_inspection_acts_status CHECK (
+        status IN ('DRAFT','LOCKED','SEALED','READY','CLOSED','CANCELLED','RECTIFIED')
+      )
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE inspection_act_versions
+      DROP CONSTRAINT IF EXISTS chk_inspection_act_versions_event
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_act_versions
+      ADD CONSTRAINT chk_inspection_act_versions_event CHECK (
+        event IN ('CREATED','UPDATED','LOCKED','SEALED','READY','REOPENED','CLOSED','CANCELLED')
+      )
+    `);
+
+    // El cierre físico F4 se representa como SEALED. Conservamos CLOSED como
+    // compatibilidad histórica y exigimos la misma integridad en ambos estados.
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      DROP CONSTRAINT IF EXISTS chk_inspection_acts_closure
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      ADD CONSTRAINT chk_inspection_acts_closure CHECK (
+        status NOT IN ('SEALED','CLOSED')
+        OR (
+          closed_at IS NOT NULL
+          AND closed_by IS NOT NULL
+          AND closure_sha256 ~ '^[0-9a-f]{64}$'
+        )
+      )
+    `);
+
+    // Las firmas F4 pertenecen al snapshot LOCKED. El trigger D5 exigía READY.
+    await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION dhv2_guard_act_signature_ready()
+      RETURNS trigger LANGUAGE plpgsql AS $$
+      DECLARE current_status varchar(24);
+      DECLARE current_sha char(64);
+      BEGIN
+        SELECT act.status, closure.prepared_sha256
+        INTO current_status, current_sha
+        FROM inspection_acts act
+        INNER JOIN inspection_act_closures closure ON closure.act_id = act.id
+        WHERE act.id = NEW.act_id;
+        IF current_status <> 'LOCKED' OR current_sha IS DISTINCT FROM NEW.prepared_sha256 THEN
+          RAISE EXCEPTION 'La firma no corresponde a un acta bloqueada vigente';
+        END IF;
+        RETURN NEW;
+      END
+      $$
+    `);
+
+    // SEALED es tan inmutable como CLOSED/RECTIFIED en el contrato histórico.
+    await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION dhv2_guard_closed_act_immutable()
+      RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        IF OLD.status IN ('SEALED','CLOSED','RECTIFIED') THEN
+          RAISE EXCEPTION 'El acta sellada es inmutable';
+        END IF;
+        RETURN NEW;
+      END
+      $$
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // El contrato D5 no conoce los estados F4. Reducimos las representaciones
+    // nuevas a sus equivalentes históricos antes de restaurar sus CHECKs.
+    await queryRunner.query(`
+      UPDATE inspection_reports
+      SET status='FROZEN'
+      WHERE status IN ('WORKING','OFFICIALIZED')
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_reports
+      DROP CONSTRAINT IF EXISTS chk_inspection_reports_status
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_reports
+      ADD CONSTRAINT chk_inspection_reports_status CHECK (
+        status IN ('FROZEN','CANCELLED')
+      )
+    `);
+
+    await queryRunner.query(`
+      UPDATE inspection_acts
+      SET status=CASE
+        WHEN status='LOCKED' THEN 'READY'
+        WHEN status='SEALED' THEN 'CLOSED'
+        ELSE status
+      END
+      WHERE status IN ('LOCKED','SEALED')
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      DROP CONSTRAINT IF EXISTS chk_inspection_acts_status
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      ADD CONSTRAINT chk_inspection_acts_status CHECK (
+        status IN ('DRAFT','READY','CLOSED','CANCELLED','RECTIFIED')
+      )
+    `);
+
+    await queryRunner.query(`
+      UPDATE inspection_act_versions
+      SET event=CASE
+        WHEN event='LOCKED' THEN 'READY'
+        WHEN event='SEALED' THEN 'CLOSED'
+        ELSE event
+      END
+      WHERE event IN ('LOCKED','SEALED')
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_act_versions
+      DROP CONSTRAINT IF EXISTS chk_inspection_act_versions_event
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_act_versions
+      ADD CONSTRAINT chk_inspection_act_versions_event CHECK (
+        event IN ('CREATED','UPDATED','READY','REOPENED','CLOSED','CANCELLED')
+      )
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      DROP CONSTRAINT IF EXISTS chk_inspection_acts_closure
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      ADD CONSTRAINT chk_inspection_acts_closure CHECK (
+        status <> 'CLOSED'
+        OR (
+          closed_at IS NOT NULL
+          AND closed_by IS NOT NULL
+          AND closure_sha256 ~ '^[0-9a-f]{64}$'
+        )
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION dhv2_guard_act_signature_ready()
+      RETURNS trigger LANGUAGE plpgsql AS $$
+      DECLARE current_status varchar(24);
+      DECLARE current_sha char(64);
+      BEGIN
+        SELECT act.status, closure.prepared_sha256
+        INTO current_status, current_sha
+        FROM inspection_acts act
+        INNER JOIN inspection_act_closures closure ON closure.act_id = act.id
+        WHERE act.id = NEW.act_id;
+        IF current_status <> 'READY' OR current_sha IS DISTINCT FROM NEW.prepared_sha256 THEN
+          RAISE EXCEPTION 'La firma no corresponde a un acta preparada vigente';
+        END IF;
+        RETURN NEW;
+      END
+      $$
+    `);
+
+    await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION dhv2_guard_closed_act_immutable()
+      RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        IF OLD.status IN ('CLOSED','RECTIFIED') THEN
+          RAISE EXCEPTION 'El acta cerrada es inmutable';
+        END IF;
+        RETURN NEW;
+      END
+      $$
+    `);
+  }
+}

From 57739dcb3eb340dbdfa39e2d4646b57ef5d0c77f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:24:50 -0300
Subject: [PATCH 179/224] fix: make F4 lifecycle constraint rollback executable

---
 ...f4-align-document-lifecycle-constraints.ts | 26 ++++++++++---------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
index 4800de9..1c8d62b 100644
--- a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
+++ b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
@@ -97,6 +97,20 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
+    // Primero restauramos la guarda D5. De otro modo el propio trigger F4 impediría
+    // traducir una fila SEALED a CLOSED durante el rollback.
+    await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION dhv2_guard_closed_act_immutable()
+      RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        IF OLD.status IN ('CLOSED','RECTIFIED') THEN
+          RAISE EXCEPTION 'El acta cerrada es inmutable';
+        END IF;
+        RETURN NEW;
+      END
+      $$
+    `);
+
     // El contrato D5 no conoce los estados F4. Reducimos las representaciones
     // nuevas a sus equivalentes históricos antes de restaurar sus CHECKs.
     await queryRunner.query(`
@@ -189,17 +203,5 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
       END
       $$
     `);
-
-    await queryRunner.query(`
-      CREATE OR REPLACE FUNCTION dhv2_guard_closed_act_immutable()
-      RETURNS trigger LANGUAGE plpgsql AS $$
-      BEGIN
-        IF OLD.status IN ('CLOSED','RECTIFIED') THEN
-          RAISE EXCEPTION 'El acta cerrada es inmutable';
-        END IF;
-        RETURN NEW;
-      END
-      $$
-    `);
   }
 }

From 40e33f831208b7cbc72417c257cc2b92820f6477 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:25:14 -0300
Subject: [PATCH 180/224] test: lock F4 document lifecycle database contract

---
 ...cument-lifecycle-database-contract.test.ts | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts

diff --git a/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts b/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
new file mode 100644
index 0000000..08de105
--- /dev/null
+++ b/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = process.cwd();
+const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
+
+const migration = read('src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts');
+const closing = read('src/inspection-closing/inspection-closing.service.ts');
+const reports = read('src/inspection-reports/inspection-reports.service.ts');
+
+test('F4 PostgreSQL accepts the active Act and report lifecycle states emitted by services', () => {
+  assert.match(migration, /status IN \('WORKING','OFFICIALIZED','FROZEN','CANCELLED'\)/);
+  assert.match(migration, /status IN \('DRAFT','LOCKED','SEALED','READY','CLOSED','CANCELLED','RECTIFIED'\)/);
+  assert.match(reports, /'WORKING'/);
+  assert.match(closing, /status='LOCKED'/);
+  assert.match(closing, /status='SEALED'/);
+});
+
+test('F4 PostgreSQL accepts LOCKED and SEALED in the immutable Act version ledger', () => {
+  assert.match(migration, /event IN \('CREATED','UPDATED','LOCKED','SEALED','READY','REOPENED','CLOSED','CANCELLED'\)/);
+  assert.match(closing, /InspectionActVersionEvent\.LOCKED/);
+  assert.match(closing, /InspectionActVersionEvent\.SEALED/);
+});
+
+test('F4 signature trigger binds signatures to the immutable LOCKED snapshot', () => {
+  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));
+  assert.match(up, /dhv2_guard_act_signature_ready/);
+  assert.match(up, /current_status <> 'LOCKED'/);
+  assert.match(up, /current_sha IS DISTINCT FROM NEW\.prepared_sha256/);
+  assert.match(up, /OLD\.status IN \('SEALED','CLOSED','RECTIFIED'\)/);
+});
+
+test('F4 SEALED rows require closure metadata at database level', () => {
+  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));
+  assert.match(up, /status NOT IN \('SEALED','CLOSED'\)/);
+  assert.match(up, /closed_at IS NOT NULL/);
+  assert.match(up, /closed_by IS NOT NULL/);
+  assert.match(up, /closure_sha256 ~ '\^\[0-9a-f\]\{64\}\$'/);
+});
+
+test('F4 lifecycle rollback translates new states before restoring legacy CHECKs', () => {
+  const down = migration.slice(migration.indexOf('  public async down('));
+  const guardRestore = down.indexOf("OLD.status IN ('CLOSED','RECTIFIED')");
+  const actTranslation = down.indexOf('UPDATE inspection_acts');
+  assert.ok(guardRestore >= 0);
+  assert.ok(actTranslation > guardRestore, 'Debe restaurarse primero la guarda D5 para poder traducir SEALED a CLOSED');
+  assert.match(down, /WHEN status='LOCKED' THEN 'READY'/);
+  assert.match(down, /WHEN status='SEALED' THEN 'CLOSED'/);
+  assert.match(down, /WHEN event='LOCKED' THEN 'READY'/);
+  assert.match(down, /WHEN event='SEALED' THEN 'CLOSED'/);
+  assert.match(down, /SET status='FROZEN'/);
+});

From 345ef76820005585658faaff6b1fe6219c4fbc89 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:27:29 -0300
Subject: [PATCH 181/224] fix: align F4 Act code constraint with generated
 codes

---
 ...f4-align-document-lifecycle-constraints.ts | 36 +++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
index 1c8d62b..cf2ec85 100644
--- a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
+++ b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
@@ -4,8 +4,9 @@ import { MigrationInterface, QueryRunner } from 'typeorm';
  * Alinea las restricciones físicas heredadas de D5 con el ciclo documental F4.
  *
  * F4 incorpora estados LOCKED/SEALED para Actas y WORKING/OFFICIALIZED para INF.
- * Las migraciones históricas conservaban CHECKs y triggers de READY/CLOSED/FROZEN,
- * por lo que el servicio podía compilar pero PostgreSQL rechazaba las transiciones.
+ * También usa el código visible ACT-NNNNN-DD-MM-YY. Las migraciones históricas
+ * conservaban CHECKs, triggers y el formato ACTA-YYYY-NNNNNN de D5, por lo que
+ * el servicio podía compilar pero PostgreSQL rechazaba las transiciones nuevas.
  */
 export class F4AlignDocumentLifecycleConstraints1790000600000 implements MigrationInterface {
   name = 'F4AlignDocumentLifecycleConstraints1790000600000';
@@ -33,6 +34,19 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
       )
     `);
 
+    // Conservamos los códigos históricos ACTA-* ya emitidos y habilitamos el
+    // formato F4 realmente generado por InspectionActsService.
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      DROP CONSTRAINT IF EXISTS chk_inspection_acts_code
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      ADD CONSTRAINT chk_inspection_acts_code CHECK (
+        code ~ '^(ACTA-[0-9]{4}-[0-9]{6}|ACT-[0-9]{5}-[0-9]{2}-[0-9]{2}-[0-9]{2})$'
+      )
+    `);
+
     await queryRunner.query(`
       ALTER TABLE inspection_act_versions
       DROP CONSTRAINT IF EXISTS chk_inspection_act_versions_event
@@ -111,6 +125,24 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
       $$
     `);
 
+    // Los códigos F4 se traducen antes de convertir SEALED a CLOSED, porque una vez
+    // restaurada la guarda D5 una fila CLOSED ya no puede modificarse.
+    await queryRunner.query(`
+      UPDATE inspection_acts
+      SET code='ACTA-' || act_year::text || '-' || LPAD(act_number::text, 6, '0')
+      WHERE code ~ '^ACT-[0-9]{5}-[0-9]{2}-[0-9]{2}-[0-9]{2}$'
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      DROP CONSTRAINT IF EXISTS chk_inspection_acts_code
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_acts
+      ADD CONSTRAINT chk_inspection_acts_code CHECK (
+        code ~ '^ACTA-[0-9]{4}-[0-9]{6}$'
+      )
+    `);
+
     // El contrato D5 no conoce los estados F4. Reducimos las representaciones
     // nuevas a sus equivalentes históricos antes de restaurar sus CHECKs.
     await queryRunner.query(`

From 80275969c918a35f3a2e89ffc4c1e9fc27d3a4cd Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:27:58 -0300
Subject: [PATCH 182/224] test: cover F4 Act code database constraint

---
 ...4-document-lifecycle-database-contract.test.ts | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts b/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
index 08de105..c922beb 100644
--- a/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
+++ b/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
@@ -9,6 +9,7 @@ const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'u
 const migration = read('src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts');
 const closing = read('src/inspection-closing/inspection-closing.service.ts');
 const reports = read('src/inspection-reports/inspection-reports.service.ts');
+const acts = read('src/inspection-acts/inspection-acts.service.ts');
 
 test('F4 PostgreSQL accepts the active Act and report lifecycle states emitted by services', () => {
   assert.match(migration, /status IN \('WORKING','OFFICIALIZED','FROZEN','CANCELLED'\)/);
@@ -18,6 +19,12 @@ test('F4 PostgreSQL accepts the active Act and report lifecycle states emitted b
   assert.match(closing, /status='SEALED'/);
 });
 
+test('F4 PostgreSQL accepts the ACT-NNNNN-DD-MM-YY code generated by the active service', () => {
+  assert.match(acts, /`ACT-\$\{String\(actNumber\)\.padStart\(5, '0'\)\}-\$\{dateRow\.date_part\}`/);
+  assert.match(migration, /ACT-\[0-9\]\{5\}-\[0-9\]\{2\}-\[0-9\]\{2\}-\[0-9\]\{2\}/);
+  assert.match(migration, /ACTA-\[0-9\]\{4\}-\[0-9\]\{6\}/);
+});
+
 test('F4 PostgreSQL accepts LOCKED and SEALED in the immutable Act version ledger', () => {
   assert.match(migration, /event IN \('CREATED','UPDATED','LOCKED','SEALED','READY','REOPENED','CLOSED','CANCELLED'\)/);
   assert.match(closing, /InspectionActVersionEvent\.LOCKED/);
@@ -40,12 +47,14 @@ test('F4 SEALED rows require closure metadata at database level', () => {
   assert.match(up, /closure_sha256 ~ '\^\[0-9a-f\]\{64\}\$'/);
 });
 
-test('F4 lifecycle rollback translates new states before restoring legacy CHECKs', () => {
+test('F4 lifecycle rollback translates new states and codes before restoring legacy CHECKs', () => {
   const down = migration.slice(migration.indexOf('  public async down('));
   const guardRestore = down.indexOf("OLD.status IN ('CLOSED','RECTIFIED')");
-  const actTranslation = down.indexOf('UPDATE inspection_acts');
+  const codeTranslation = down.indexOf("SET code='ACTA-'");
+  const actTranslation = down.indexOf('SET status=CASE');
   assert.ok(guardRestore >= 0);
-  assert.ok(actTranslation > guardRestore, 'Debe restaurarse primero la guarda D5 para poder traducir SEALED a CLOSED');
+  assert.ok(codeTranslation > guardRestore, 'Debe restaurarse primero la guarda D5 para traducir códigos F4');
+  assert.ok(actTranslation > codeTranslation, 'El código debe traducirse antes de convertir SEALED a CLOSED');
   assert.match(down, /WHEN status='LOCKED' THEN 'READY'/);
   assert.match(down, /WHEN status='SEALED' THEN 'CLOSED'/);
   assert.match(down, /WHEN event='LOCKED' THEN 'READY'/);

From 97296ba37be3be89435b4acf2268e18dfdae692e Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:29:56 -0300
Subject: [PATCH 183/224] fix: remove active Inspection title reads from Acts
 service

---
 api-v3/src/inspection-acts/inspection-acts.service.ts | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/api-v3/src/inspection-acts/inspection-acts.service.ts b/api-v3/src/inspection-acts/inspection-acts.service.ts
index 260f858..f32bbda 100644
--- a/api-v3/src/inspection-acts/inspection-acts.service.ts
+++ b/api-v3/src/inspection-acts/inspection-acts.service.ts
@@ -44,7 +44,6 @@ interface ActAsset {
 interface ActVisitSummary {
   id: string;
   code: string;
-  title: string;
   status: InspectionVisitStatus;
   actualStartedAt: Date | null;
 }
@@ -151,7 +150,6 @@ export class InspectionActsService {
         act.code ILIKE ${search}
         OR act.title ILIKE ${search}
         OR visit.code ILIKE ${search}
-        OR visit.title ILIKE ${search}
         OR EXISTS (
           SELECT 1
           FROM inspection_act_assets search_link
@@ -185,7 +183,7 @@ export class InspectionActsService {
       conditions.push(`EXISTS (
         SELECT 1
         FROM inspection_act_assets area_link
-        INNER JOIN assets area_asset ON area_asset.id = area_link.asset_id
+        INNER JOIN assets area_asset ON area_asset.id = company_link.asset_id
         WHERE area_link.act_id = act.id
           AND area_link.included = true
           AND area_asset.operational_area_id = ${add(query.areaId)}::uuid
@@ -491,7 +489,6 @@ export class InspectionActsService {
         JSONB_BUILD_OBJECT(
           'id', visit.id,
           'code', visit.code,
-          'title', visit.title,
           'status', visit.status,
           'actualStartedAt', visit.actual_started_at
         ) AS visit,
@@ -814,7 +811,6 @@ export class InspectionActsService {
         'visit', JSONB_BUILD_OBJECT(
           'id', visit.id,
           'code', visit.code,
-          'title', visit.title,
           'status', visit.status,
           'scopeAssetId', visit.scope_asset_id,
           'actualStartedAt', visit.actual_started_at

From cac3161cbbcdcd8b0bba1e79d2c5534bc771030a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:31:42 -0300
Subject: [PATCH 184/224] fix: restore area filter after Inspection title
 cleanup

---
 api-v3/src/inspection-acts/inspection-acts.service.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api-v3/src/inspection-acts/inspection-acts.service.ts b/api-v3/src/inspection-acts/inspection-acts.service.ts
index f32bbda..262c44d 100644
--- a/api-v3/src/inspection-acts/inspection-acts.service.ts
+++ b/api-v3/src/inspection-acts/inspection-acts.service.ts
@@ -183,7 +183,7 @@ export class InspectionActsService {
       conditions.push(`EXISTS (
         SELECT 1
         FROM inspection_act_assets area_link
-        INNER JOIN assets area_asset ON area_asset.id = company_link.asset_id
+        INNER JOIN assets area_asset ON area_asset.id = area_link.asset_id
         WHERE area_link.act_id = act.id
           AND area_link.included = true
           AND area_asset.operational_area_id = ${add(query.areaId)}::uuid

From 2968f83b36034a05835f377cc8f9139141e1035a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:32:56 -0300
Subject: [PATCH 185/224] test: guard active Act queries from removed
 Inspection fields

---
 api-v3/test/unit/f4-inspection-legacy-fields.test.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
index 476f8d8..432f8f0 100644
--- a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
+++ b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
@@ -1,9 +1,13 @@
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
 import test from 'node:test';
 import { getMetadataArgsStorage, type QueryRunner } from 'typeorm';
 import { InspectionVisit } from '../../src/database/entities/inspection-visit.entity';
 import { F4RemoveInspectionLegacyFields1790000500000 } from '../../src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields';
 
+const root = process.cwd();
+
 test('F4: InspectionVisit no vuelve a mapear title ni plannedEndAt', () => {
   const metadata = getMetadataArgsStorage();
   const columns = metadata.columns
@@ -20,6 +24,12 @@ test('F4: InspectionVisit no vuelve a mapear title ni plannedEndAt', () => {
   assert.equal(indexes.includes('idx_inspection_visits_planned_start_at'), true);
 });
 
+test('F4: los consumidores activos de Actas no consultan el title físico de la Inspección', () => {
+  const acts = fs.readFileSync(path.join(root, 'src/inspection-acts/inspection-acts.service.ts'), 'utf8');
+  assert.doesNotMatch(acts, /visit\.title/);
+  assert.doesNotMatch(acts, /['"]title['"]\s*,\s*visit\.title/);
+});
+
 test('F4: la migración retira las columnas legacy y conserva índice de inicio', async () => {
   const statements: string[] = [];
   const queryRunner = {

From 6f100bf9bae6c1478133f565255cf981bfcdcdef Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:35:57 -0300
Subject: [PATCH 186/224] test: align document center baseline with F4 report
 lifecycle

---
 .../test/unit/phase-d5-3-15-document-center.test.ts  | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/api-v3/test/unit/phase-d5-3-15-document-center.test.ts b/api-v3/test/unit/phase-d5-3-15-document-center.test.ts
index 52ab6ed..948a4ac 100644
--- a/api-v3/test/unit/phase-d5-3-15-document-center.test.ts
+++ b/api-v3/test/unit/phase-d5-3-15-document-center.test.ts
@@ -6,26 +6,30 @@ import { resolve } from 'node:path';
 const reportService = readFileSync(resolve(process.cwd(), 'src/inspection-reports/inspection-reports.service.ts'), 'utf8');
 const actService = readFileSync(resolve(process.cwd(), 'src/inspection-acts/inspection-acts.service.ts'), 'utf8');
 const migration = readFileSync(resolve(process.cwd(), 'src/database/migrations/1788026400000-phase-d5-3-15-document-center.ts'), 'utf8');
+const f4Lifecycle = readFileSync(resolve(process.cwd(), 'src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts'), 'utf8');
 
-test('D5.3.15 exposes global acts and pending report emission', () => {
+test('D5.3.15/F4 exposes global acts and report emission after an Act is SEALED', () => {
   assert.match(actService, /async listGlobal\(query: ListInspectionActsQueryDto\)/);
   assert.match(reportService, /async listPending\(query: ListInspectionReportsQueryDto\)/);
-  assert.match(reportService, /act\.status = 'CLOSED'/);
+  assert.match(reportService, /act\.status = 'SEALED'/);
   assert.match(reportService, /report\.id IS NULL/);
+  assert.match(reportService, /act\.closure_sha256 IS NOT NULL/);
 });
 
-test('D5.3.15 freezes a report from the final closed act snapshot', () => {
+test('D5.3.15/F4 freezes the immutable sealed Act snapshot as the INF source', () => {
   assert.match(reportService, /assertMobileInspector\(principal\)/);
   assert.match(reportService, /final_snapshot AS "finalSnapshot"/);
   assert.match(reportService, /DocumentSequenceType\.REPORT/);
   assert.match(reportService, /sha256CanonicalJson\(frozenSnapshot\)/);
+  assert.match(reportService, /InspectionReportStatus\.WORKING/);
   assert.match(reportService, /INSPECTION_REPORT_GENERATED/);
 });
 
-test('D5.3.15 migration creates independent report numbering and protected frozen content', () => {
+test('D5.3.15 frozen source guarantees survive while F4 expands report workflow states', () => {
   assert.match(migration, /CREATE TABLE inspection_reports/);
   assert.match(migration, /UNIQUE \(report_year, report_number\)/);
   assert.match(migration, /dhv2_guard_inspection_report_frozen/);
   assert.match(migration, /inspection_reports\.read/);
   assert.match(migration, /inspection_reports\.generate/);
+  assert.match(f4Lifecycle, /status IN \('WORKING','OFFICIALIZED','FROZEN','CANCELLED'\)/);
 });

From ff7a99725e0fc0000be85d02d72147e8a6dc58a9 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:38:18 -0300
Subject: [PATCH 187/224] fix: align F4 document delivery recipient constraint

---
 ...f4-align-document-lifecycle-constraints.ts | 33 +++++++++++++++++--
 1 file changed, 30 insertions(+), 3 deletions(-)

diff --git a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
index cf2ec85..6171183 100644
--- a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
+++ b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
@@ -4,9 +4,9 @@ import { MigrationInterface, QueryRunner } from 'typeorm';
  * Alinea las restricciones físicas heredadas de D5 con el ciclo documental F4.
  *
  * F4 incorpora estados LOCKED/SEALED para Actas y WORKING/OFFICIALIZED para INF.
- * También usa el código visible ACT-NNNNN-DD-MM-YY. Las migraciones históricas
- * conservaban CHECKs, triggers y el formato ACTA-YYYY-NNNNNN de D5, por lo que
- * el servicio podía compilar pero PostgreSQL rechazaba las transiciones nuevas.
+ * También usa el código visible ACT-NNNNN-DD-MM-YY y entrega copia al INSPECTOR.
+ * Las migraciones históricas conservaban CHECKs, triggers y contratos de D5, por lo
+ * que el servicio podía compilar pero PostgreSQL rechazaba las transiciones nuevas.
  */
 export class F4AlignDocumentLifecycleConstraints1790000600000 implements MigrationInterface {
   name = 'F4AlignDocumentLifecycleConstraints1790000600000';
@@ -76,6 +76,19 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
       )
     `);
 
+    // F4 retira Director como destinatario activo y agrega copia al inspector.
+    // La migración 040 ya eliminó previamente las filas DIRECTOR existentes.
+    await queryRunner.query(`
+      ALTER TABLE inspection_document_deliveries
+      DROP CONSTRAINT IF EXISTS chk_inspection_document_deliveries_recipient_kind
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_document_deliveries
+      ADD CONSTRAINT chk_inspection_document_deliveries_recipient_kind CHECK (
+        recipient_kind IN ('COMPANY','OFFICE','INSPECTOR')
+      )
+    `);
+
     // Las firmas F4 pertenecen al snapshot LOCKED. El trigger D5 exigía READY.
     await queryRunner.query(`
       CREATE OR REPLACE FUNCTION dhv2_guard_act_signature_ready()
@@ -217,6 +230,20 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
       )
     `);
 
+    // Conservamos INSPECTOR en el CHECK de rollback para no destruir ni falsificar
+    // entregas F4 ya auditadas. D5 puede seguir operando con sus tres valores y el
+    // backup PRE-F4 sigue siendo la fuente de una restauración histórica exacta.
+    await queryRunner.query(`
+      ALTER TABLE inspection_document_deliveries
+      DROP CONSTRAINT IF EXISTS chk_inspection_document_deliveries_recipient_kind
+    `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_document_deliveries
+      ADD CONSTRAINT chk_inspection_document_deliveries_recipient_kind CHECK (
+        recipient_kind IN ('COMPANY','OFFICE','DIRECTOR','INSPECTOR')
+      )
+    `);
+
     await queryRunner.query(`
       CREATE OR REPLACE FUNCTION dhv2_guard_act_signature_ready()
       RETURNS trigger LANGUAGE plpgsql AS $$

From 7174d379e53537b0ab44d3b2ab0703074e78b652 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:38:52 -0300
Subject: [PATCH 188/224] test: cover F4 inspector delivery database contract

---
 .../f4-document-lifecycle-database-contract.test.ts    | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts b/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
index c922beb..a233155 100644
--- a/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
+++ b/api-v3/test/unit/f4-document-lifecycle-database-contract.test.ts
@@ -10,6 +10,7 @@ const migration = read('src/database/migrations/1790000600000-f4-align-document-
 const closing = read('src/inspection-closing/inspection-closing.service.ts');
 const reports = read('src/inspection-reports/inspection-reports.service.ts');
 const acts = read('src/inspection-acts/inspection-acts.service.ts');
+const delivery = read('src/inspection-reports/inspection-document-delivery.service.ts');
 
 test('F4 PostgreSQL accepts the active Act and report lifecycle states emitted by services', () => {
   assert.match(migration, /status IN \('WORKING','OFFICIALIZED','FROZEN','CANCELLED'\)/);
@@ -31,6 +32,14 @@ test('F4 PostgreSQL accepts LOCKED and SEALED in the immutable Act version ledge
   assert.match(closing, /InspectionActVersionEvent\.SEALED/);
 });
 
+test('F4 delivery constraint accepts INSPECTOR and retires DIRECTOR from the active contract', () => {
+  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));
+  assert.match(delivery, /'COMPANY' \| 'OFFICE' \| 'INSPECTOR'/);
+  assert.match(delivery, /recipientKind:'INSPECTOR'/);
+  assert.match(up, /recipient_kind IN \('COMPANY','OFFICE','INSPECTOR'\)/);
+  assert.doesNotMatch(up, /recipient_kind IN \('COMPANY','OFFICE','DIRECTOR'\)/);
+});
+
 test('F4 signature trigger binds signatures to the immutable LOCKED snapshot', () => {
   const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));
   assert.match(up, /dhv2_guard_act_signature_ready/);
@@ -60,4 +69,5 @@ test('F4 lifecycle rollback translates new states and codes before restoring leg
   assert.match(down, /WHEN event='LOCKED' THEN 'READY'/);
   assert.match(down, /WHEN event='SEALED' THEN 'CLOSED'/);
   assert.match(down, /SET status='FROZEN'/);
+  assert.match(down, /recipient_kind IN \('COMPANY','OFFICE','DIRECTOR','INSPECTOR'\)/);
 });

From afb6feb4c1cda5f9189fbc8d101380272fbad11a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 09:58:12 -0300
Subject: [PATCH 189/224] test(f4): harden multi-act immutability gates

---
 .../test/unit/f4-multi-act-lifecycle.test.ts  | 47 +++++++++++++++++--
 1 file changed, 42 insertions(+), 5 deletions(-)

diff --git a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
index 29594ce..1e697e8 100644
--- a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
+++ b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
@@ -8,6 +8,8 @@ const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'u
 
 const closing = read('src/inspection-closing/inspection-closing.service.ts');
 const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
+const acts = read('src/inspection-acts/inspection-acts.service.ts');
+const findings = read('src/inspection-findings/inspection-findings.service.ts');
 const actEntity = read('src/database/entities/inspection-act.entity.ts');
 
 test('F4 keeps finalized acts irreversible', () => {
@@ -31,17 +33,52 @@ test('F4 act locking is independent from inspection-wide verification completion
   assert.match(prepareBody, /status='LOCKED'/);
 });
 
-test('F4 inspection close is the aggregate gate for sealed acts and verification results', () => {
+test('F4 blocks act header and inventory mutations once the act leaves draft', () => {
+  const updateBody = acts.slice(acts.indexOf('  async update('), acts.indexOf('  async cancel('));
+  const cancelBody = acts.slice(acts.indexOf('  async cancel('), acts.indexOf('  async getById('));
+  assert.match(updateBody, /this\.assertActDraft\(act\)/);
+  assert.match(cancelBody, /this\.assertActDraft\(act\)/);
+});
+
+test('F4 blocks finding creation and editing once the act is locked', () => {
+  const editableGuard = findings.slice(
+    findings.indexOf('  private assertActEditable('),
+    findings.indexOf('  private assertFindingOpen('),
+  );
+  assert.match(editableGuard, /act\.status !== InspectionActStatus\.DRAFT/);
+  assert.match(editableGuard, /visit\.status !== InspectionVisitStatus\.IN_PROGRESS/);
+  assert.match(editableGuard, /INSPECTION_FINDING_ACT_NOT_EDITABLE/);
+
+  const createBody = findings.slice(findings.indexOf('  async create('), findings.indexOf('  async update('));
+  const updateBody = findings.slice(findings.indexOf('  async update('), findings.indexOf('  async updateFollowUp('));
+  assert.match(createBody, /this\.assertActEditable\(act, visit\)/);
+  assert.match(updateBody, /this\.assertActEditable\(act, visit\)/);
+});
+
+test('F4 sealing requires inspector signature and exactly one resolved company manifestation', () => {
+  const closeBody = closing.slice(closing.indexOf('  async close('), closing.indexOf('  async signatureContent('));
+  assert.match(closeBody, /INSPECTION_ACT_INSPECTOR_SIGNATURE_REQUIRED/);
+  assert.match(closeBody, /companyOutcomes\.length !== 1/);
+  assert.match(closeBody, /INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED/);
+  assert.match(closeBody, /InspectionActSignatureStatus\.ABSENT/);
+  assert.match(closeBody, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);
+  assert.match(closeBody, /status='SEALED'/);
+});
+
+test('F4 inspection close is the aggregate gate for every non-cancelled act and verification result', () => {
   const closeBody = lifecycle.slice(lifecycle.indexOf('  async close('), lifecycle.indexOf('  async cancel('));
-  assert.match(closeBody, /status<>'CANCELLED'/);
-  assert.match(closeBody, /act\.status !== 'SEALED'/);
+  assert.match(closeBody, /WHERE visit_id=\$1 AND status<>'CANCELLED'/);
+  assert.match(closeBody, /acts\.length === 0/);
+  assert.match(closeBody, /INSPECTION_REQUIRES_ACT/);
+  assert.match(closeBody, /acts\.filter\(\(act\) => act\.status !== 'SEALED'\)/);
   assert.match(closeBody, /INSPECTION_ACTS_NOT_SEALED/);
+  assert.match(closeBody, /pendingActs: pending\.map/);
   assert.match(closeBody, /assertVerificationResultsComplete\(manager, id\)/);
   assert.match(closeBody, /InspectionVisitStatus\.CLOSED/);
 });
 
-test('F4 prevents cancelling an inspection that already has a sealed act', () => {
+test('F4 prevents cancelling an inspection that already has any sealed act', () => {
   const cancelBody = lifecycle.slice(lifecycle.indexOf('  async cancel('), lifecycle.indexOf('  private async lockVisit('));
-  assert.match(cancelBody, /status='SEALED'/);
+  assert.match(cancelBody, /WHERE visit_id=\$1 AND status='SEALED'/);
   assert.match(cancelBody, /INSPECTION_WITH_SEALED_ACT_CANNOT_CANCEL/);
 });

From 2c1fdf7fb272a9e29b06924696a772787d651dc7 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:00:24 -0300
Subject: [PATCH 190/224] test(f4): make lifecycle source boundaries
 deterministic

---
 api-v3/test/unit/f4-multi-act-lifecycle.test.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
index 1e697e8..a06f47e 100644
--- a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
+++ b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
@@ -35,7 +35,7 @@ test('F4 act locking is independent from inspection-wide verification completion
 
 test('F4 blocks act header and inventory mutations once the act leaves draft', () => {
   const updateBody = acts.slice(acts.indexOf('  async update('), acts.indexOf('  async cancel('));
-  const cancelBody = acts.slice(acts.indexOf('  async cancel('), acts.indexOf('  async getById('));
+  const cancelBody = acts.slice(acts.indexOf('  async cancel('), acts.indexOf('  private actSelect('));
   assert.match(updateBody, /this\.assertActDraft\(act\)/);
   assert.match(cancelBody, /this\.assertActDraft\(act\)/);
 });
@@ -50,7 +50,7 @@ test('F4 blocks finding creation and editing once the act is locked', () => {
   assert.match(editableGuard, /INSPECTION_FINDING_ACT_NOT_EDITABLE/);
 
   const createBody = findings.slice(findings.indexOf('  async create('), findings.indexOf('  async update('));
-  const updateBody = findings.slice(findings.indexOf('  async update('), findings.indexOf('  async updateFollowUp('));
+  const updateBody = findings.slice(findings.indexOf('  async update('), findings.indexOf('  async close('));
   assert.match(createBody, /this\.assertActEditable\(act, visit\)/);
   assert.match(updateBody, /this\.assertActEditable\(act, visit\)/);
 });

From c28e5b060ddaefdf3c0bd339f07d7a977852da8a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:01:38 -0300
Subject: [PATCH 191/224] test(f4): lock field finding and sequential multi-act
 contracts

---
 .../test/unit/f4-multi-act-lifecycle.test.ts  | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
index a06f47e..93c6a4c 100644
--- a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
+++ b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
@@ -10,6 +10,7 @@ const closing = read('src/inspection-closing/inspection-closing.service.ts');
 const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
 const acts = read('src/inspection-acts/inspection-acts.service.ts');
 const findings = read('src/inspection-findings/inspection-findings.service.ts');
+const fieldFindings = read('src/inspection-visits/field-findings.service.ts');
 const actEntity = read('src/database/entities/inspection-act.entity.ts');
 
 test('F4 keeps finalized acts irreversible', () => {
@@ -24,6 +25,16 @@ test('F4 permits multiple acts per inspection but only one simultaneous draft',
   assert.match(actEntity, /uq_inspection_acts_one_draft_per_visit/);
   assert.match(actEntity, /where: "status = 'DRAFT'"/);
   assert.doesNotMatch(actEntity, /uq_inspection_acts_visit['"]/);
+
+  const createBody = acts.slice(acts.indexOf('  async create('), acts.indexOf('  async update('));
+  const singleDraftGuard = acts.slice(
+    acts.indexOf('  private async assertVisitHasNoDraftAct('),
+    acts.indexOf('  private async assertVisitAssets('),
+  );
+  assert.match(createBody, /this\.assertVisitOpen\(visit\)/);
+  assert.match(createBody, /this\.assertVisitHasNoDraftAct\(manager, visitId\)/);
+  assert.match(singleDraftGuard, /WHERE visit_id = \$1 AND status = 'DRAFT'/);
+  assert.doesNotMatch(singleDraftGuard, /LOCKED|SEALED/);
 });
 
 test('F4 act locking is independent from inspection-wide verification completion', () => {
@@ -55,6 +66,20 @@ test('F4 blocks finding creation and editing once the act is locked', () => {
   assert.match(updateBody, /this\.assertActEditable\(act, visit\)/);
 });
 
+test('F4 field finding flow only targets a draft act of the same in-progress inspection', () => {
+  const createBody = fieldFindings.slice(fieldFindings.indexOf('  async create('), fieldFindings.indexOf('  private async requireGate('));
+  const draftGuard = fieldFindings.slice(
+    fieldFindings.indexOf('  private async requireDraftAct('),
+    fieldFindings.lastIndexOf('\n}'),
+  );
+  assert.match(createBody, /this\.requireDraftAct\(visitId, dto\.actId\)/);
+  assert.match(createBody, /this\.findings\.create\(act\.id, payload, principal, request\)/);
+  assert.match(fieldFindings, /row\.visitStatus !== 'IN_PROGRESS'/);
+  assert.match(draftGuard, /act\.status !== 'DRAFT'/);
+  assert.match(draftGuard, /FIELD_FINDING_ACT_NOT_DRAFT/);
+  assert.match(draftGuard, /WHERE visit_id = \$1::uuid[\s\S]*AND status = 'DRAFT'/);
+});
+
 test('F4 sealing requires inspector signature and exactly one resolved company manifestation', () => {
   const closeBody = closing.slice(closing.indexOf('  async close('), closing.indexOf('  async signatureContent('));
   assert.match(closeBody, /INSPECTION_ACT_INSPECTOR_SIGNATURE_REQUIRED/);

From 61f77505df8478c058d4888f43d31346aa7cc5e5 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:08:39 -0300
Subject: [PATCH 192/224] fix(f4): remove legacy inspection titles from
 findings

---
 .../inspection-findings/inspection-findings.service.ts | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/api-v3/src/inspection-findings/inspection-findings.service.ts b/api-v3/src/inspection-findings/inspection-findings.service.ts
index 9f58330..be0700f 100644
--- a/api-v3/src/inspection-findings/inspection-findings.service.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.service.ts
@@ -62,7 +62,6 @@ interface FindingDocumentView {
   actStatus: InspectionActStatus;
   visitId: string;
   visitCode: string;
-  visitTitle: string;
   visitStatus: InspectionVisitStatus;
 }
 
@@ -99,7 +98,6 @@ export interface InspectionFindingListItem {
   verificationVisit: {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
     plannedStartAt: Date | null;
   } | null;
@@ -112,7 +110,7 @@ export interface InspectionFindingListItem {
     resultNotes: string | null;
     verifiedAt: Date | null;
     resultRecordedAt: Date | null;
-    rescheduledControlOn: string | null;
+    rescheduledControlOn: Date | null;
     evidenceCount: number;
   } | null;
   createdAt: Date;
@@ -143,7 +141,6 @@ export interface FindingVerificationHistoryEvent {
   verificationVisit: {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
     plannedStartAt: Date | null;
   } | null;
@@ -811,13 +808,11 @@ export class InspectionFindingsService {
           'actStatus', act.status,
           'visitId', visit.id,
           'visitCode', visit.code,
-          'visitTitle', visit.title,
           'visitStatus', visit.status
         ) AS document,
         CASE WHEN verification_visit.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
           'id', verification_visit.id,
           'code', verification_visit.code,
-          'title', verification_visit.title,
           'status', verification_visit.status,
           'plannedStartAt', verification_visit.planned_start_at
         ) END AS "verificationVisit",
@@ -845,7 +840,7 @@ export class InspectionFindingsService {
       LEFT JOIN finding_catalog_items catalog ON catalog.id = finding.catalog_item_id
       LEFT JOIN finding_categories category ON category.id = catalog.category_id
       LEFT JOIN LATERAL (
-        SELECT verification_target.id, verification_target.code, verification_target.title,
+        SELECT verification_target.id, verification_target.code,
           verification_target.status, verification_target.planned_start_at
         FROM inspection_finding_verification_visits verification_link
         INNER JOIN inspection_visits verification_target ON verification_target.id = verification_link.visit_id
@@ -923,7 +918,6 @@ export class InspectionFindingsService {
         CASE WHEN visit.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
           'id', visit.id,
           'code', visit.code,
-          'title', visit.title,
           'status', visit.status,
           'plannedStartAt', visit.planned_start_at
         ) END AS "verificationVisit",

From 53db8b93bb90892e5fffe090fe30022689b840e4 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:10:45 -0300
Subject: [PATCH 193/224] fix(f4): preserve finding verification date contract

---
 api-v3/src/inspection-findings/inspection-findings.service.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api-v3/src/inspection-findings/inspection-findings.service.ts b/api-v3/src/inspection-findings/inspection-findings.service.ts
index be0700f..54bc171 100644
--- a/api-v3/src/inspection-findings/inspection-findings.service.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.service.ts
@@ -110,7 +110,7 @@ export interface InspectionFindingListItem {
     resultNotes: string | null;
     verifiedAt: Date | null;
     resultRecordedAt: Date | null;
-    rescheduledControlOn: Date | null;
+    rescheduledControlOn: string | null;
     evidenceCount: number;
   } | null;
   createdAt: Date;

From 7b9d2b7903f084c39abcdb79dc5ffdb42dc01693 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:11:33 -0300
Subject: [PATCH 194/224] test(f4): guard inspection legacy fields across
 backend and web

---
 .../unit/f4-inspection-legacy-fields.test.ts  | 29 +++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
index 432f8f0..54027ac 100644
--- a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
+++ b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
@@ -7,6 +7,7 @@ import { InspectionVisit } from '../../src/database/entities/inspection-visit.en
 import { F4RemoveInspectionLegacyFields1790000500000 } from '../../src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields';
 
 const root = process.cwd();
+const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
 
 test('F4: InspectionVisit no vuelve a mapear title ni plannedEndAt', () => {
   const metadata = getMetadataArgsStorage();
@@ -24,10 +25,34 @@ test('F4: InspectionVisit no vuelve a mapear title ni plannedEndAt', () => {
   assert.equal(indexes.includes('idx_inspection_visits_planned_start_at'), true);
 });
 
-test('F4: los consumidores activos de Actas no consultan el title físico de la Inspección', () => {
-  const acts = fs.readFileSync(path.join(root, 'src/inspection-acts/inspection-acts.service.ts'), 'utf8');
+test('F4: los consumidores backend activos no consultan el title físico de la Inspección', () => {
+  const acts = read('src/inspection-acts/inspection-acts.service.ts');
+  const findings = read('src/inspection-findings/inspection-findings.service.ts');
+
   assert.doesNotMatch(acts, /visit\.title/);
   assert.doesNotMatch(acts, /['"]title['"]\s*,\s*visit\.title/);
+  assert.doesNotMatch(findings, /visit\.title/);
+  assert.doesNotMatch(findings, /verification_target\.title/);
+  assert.doesNotMatch(findings, /visitTitle/);
+});
+
+test('F4: el contrato WEB de Inspecciones no reintroduce title, visitTitle ni plannedEndAt', () => {
+  const webApi = read('../web-v2/src/lib/api.ts');
+  const start = webApi.indexOf('export type InspectionVisitStatus');
+  const end = webApi.indexOf('let csrfToken: string | null');
+  assert.notEqual(start, -1);
+  assert.notEqual(end, -1);
+  const inspectionContract = webApi.slice(start, end);
+  const visitListStart = inspectionContract.indexOf('export interface InspectionVisitListItem');
+  const visitListEnd = inspectionContract.indexOf('export type InspectionVerificationOutcome');
+  assert.notEqual(visitListStart, -1);
+  assert.notEqual(visitListEnd, -1);
+  const visitListContract = inspectionContract.slice(visitListStart, visitListEnd);
+
+  assert.doesNotMatch(visitListContract, /\btitle\s*:/);
+  assert.doesNotMatch(visitListContract, /\bplannedEndAt\b/);
+  assert.doesNotMatch(inspectionContract, /\bvisitTitle\b/);
+  assert.doesNotMatch(inspectionContract, /\bplannedEndAt\b/);
 });
 
 test('F4: la migración retira las columnas legacy y conserva índice de inicio', async () => {

From f7a4e7f22803fce1cc5b8f9ed507801c333876dc Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:18:42 -0300
Subject: [PATCH 195/224] fix(f4): align web inspection legacy contract

---
 web-v2/src/lib/api.ts | 25 ++++++-------------------
 1 file changed, 6 insertions(+), 19 deletions(-)

diff --git a/web-v2/src/lib/api.ts b/web-v2/src/lib/api.ts
index d4885d2..e644809 100644
--- a/web-v2/src/lib/api.ts
+++ b/web-v2/src/lib/api.ts
@@ -302,12 +302,12 @@ export interface AssetDossier {
     inspections: number; acts: number; findings: number; openFindings: number; closedFindings: number;
     evidence: number; documents: number; photos: number; reports: number; verifications: number;
   };
-  visits: Array<{ id: string; code: string; title: string; status: InspectionVisitStatus; plannedStartAt: string | null; actualStartedAt: string | null; actualClosedAt: string | null; createdAt: string }>;
-  acts: Array<{ id: string; visitId: string; code: string; status: InspectionActStatus; occurredAt: string; title: string; summary: string; closedAt: string | null; currentVersion: number; visitCode: string; visitTitle: string }>;
-  findings: Array<{ id: string; actId: string; code: string; status: InspectionFindingStatus; title: string; description: string; correctionDueOn: string | null; companyResponseReceivedOn: string | null; nextControlOn: string | null; closedAt: string | null; closureNotes: string | null; createdAt: string; updatedAt: string; actCode: string; actOccurredAt: string; visitId: string; visitCode: string; visitTitle: string }>;
+  visits: Array<{ id: string; code: string; status: InspectionVisitStatus; plannedStartAt: string | null; actualStartedAt: string | null; actualClosedAt: string | null; createdAt: string }>;
+  acts: Array<{ id: string; visitId: string; code: string; status: InspectionActStatus; occurredAt: string; title: string; summary: string; closedAt: string | null; currentVersion: number; visitCode: string }>;
+  findings: Array<{ id: string; actId: string; code: string; status: InspectionFindingStatus; title: string; description: string; correctionDueOn: string | null; companyResponseReceivedOn: string | null; nextControlOn: string | null; closedAt: string | null; closureNotes: string | null; createdAt: string; updatedAt: string; actCode: string; actOccurredAt: string; visitId: string; visitCode: string }>;
   evidence: Array<{ id: string; findingId: string; communicationId: string | null; kind: InspectionEvidenceKind; purpose: InspectionEvidencePurpose; originalName: string; title: string | null; description: string | null; capturedAt: string | null; createdAt: string; findingCode: string; findingTitle: string }>;
   communications: Array<{ id: string; findingId: string; direction: InspectionFindingCommunication['direction']; channel: InspectionFindingCommunication['channel']; type: InspectionFindingCommunication['type']; occurredAt: string; subject: string; details: string | null; contactName: string | null; createdAt: string; findingCode: string; findingTitle: string }>;
-  verificationResults: Array<{ id: string; findingId: string; findingCode: string; findingTitle: string; visitId: string; visitCode: string; visitTitle: string; visitStatus: InspectionVisitStatus; targetControlOn: string | null; outcome: InspectionVerificationOutcome | null; resultNotes: string | null; verifiedAt: string | null; resultRecordedAt: string | null; rescheduledControlOn: string | null; evidenceCount: number }>;
+  verificationResults: Array<{ id: string; findingId: string; findingCode: string; findingTitle: string; visitId: string; visitCode: string; visitStatus: InspectionVisitStatus; targetControlOn: string | null; outcome: InspectionVerificationOutcome | null; resultNotes: string | null; verifiedAt: string | null; resultRecordedAt: string | null; rescheduledControlOn: string | null; evidenceCount: number }>;
   documents: Array<{ id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string; issuer: string | null; documentDate: string | null; externalReference: string | null; relationType: AssetSourceDocumentRelationType; notes: string | null; linkedAt: string }>;
   inspectionReports: Array<{ id: string; code: string; status: InspectionReportStatus; pdfStatus: InspectionReportPdfStatus; title: string; generatedAt: string; frozenSha256: string; actId: string; actCode: string; visitId: string; visitCode: string }>;
   reports: Array<{ id: string; documentType: SourceDocumentType; documentNumber: string | null; title: string; issuer: string | null; documentDate: string | null; externalReference: string | null; relationType: AssetSourceDocumentRelationType; notes: string | null; linkedAt: string }>;
@@ -348,7 +348,7 @@ export interface FieldDiscovery {
     id: string; code: string; name: string; commonName: string | null; informationStatus: AssetInformationStatus;
     typeId: string; typeName: string; parentId: string | null; operationalAreaId: string | null; operatorCompanyId: string | null;
   };
-  visit: { id: string; code: string; title: string; status: InspectionVisitStatus };
+  visit: { id: string; code: string; status: InspectionVisitStatus };
   creator: { id: string; username: string; firstName: string; lastName: string };
   reviewer: { id: string; username: string; firstName: string; lastName: string } | null;
   matchedAsset: { id: string; code: string; name: string; commonName: string | null } | null;
@@ -884,7 +884,6 @@ export interface InspectionVisitChecklistSummary {
 export interface InspectionVisitListItem {
   id: string;
   code: string;
-  title: string;
   objective: string | null;
   status: InspectionVisitStatus;
   scopeAsset: InspectionAssetSummary | null;
@@ -892,7 +891,6 @@ export interface InspectionVisitListItem {
   operatorCompany: InspectionPlanningContextAsset | null;
   leadInspector: InspectionPerson | null;
   plannedStartAt: string | null;
-  plannedEndAt: string | null;
   actualStartedAt: string | null;
   actualClosedAt: string | null;
   instructions: string | null;
@@ -945,7 +943,6 @@ export interface InspectionActListItem {
   visit: {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
     actualStartedAt: string | null;
   };
@@ -1031,7 +1028,6 @@ export interface InspectionReportListItem {
   visit: {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
   };
   companies: Array<{ id: string; code: string; name: string }>;
@@ -1091,7 +1087,6 @@ export interface PendingInspectionReportItem {
   closedAt: string;
   closureSha256: string;
   visitCode: string;
-  visitTitle: string;
   companies: Array<{ id: string; code: string; name: string }>;
   areas: Array<{ id: string; code: string; name: string }>;
   findingCount: number;
@@ -1347,14 +1342,12 @@ export interface VerificationPlanningItem {
   company: { id: string; code: string; name: string } | null;
   area: { id: string; code: string; name: string } | null;
   act: { id: string; code: string };
-  sourceVisit: { id: string; code: string; title: string };
+  sourceVisit: { id: string; code: string };
   verificationVisit: null | {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
     plannedStartAt: string | null;
-    plannedEndAt: string | null;
   };
 }
 
@@ -1374,10 +1367,8 @@ export interface PlannedVerificationVisitResult {
   visit: {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
     plannedStartAt: string | null;
-    plannedEndAt: string | null;
   };
   company: { id: string; code: string; name: string };
   area: { id: string; code: string; name: string };
@@ -1407,7 +1398,6 @@ export interface InspectionFindingVerificationEvent {
   verificationVisit: null | {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
     plannedStartAt: string | null;
   };
@@ -1475,13 +1465,11 @@ export interface InspectionFinding {
     actStatus: InspectionActStatus;
     visitId: string;
     visitCode: string;
-    visitTitle: string;
     visitStatus: InspectionVisitStatus;
   };
   verificationVisit: null | {
     id: string;
     code: string;
-    title: string;
     status: InspectionVisitStatus;
     plannedStartAt: string | null;
   };
@@ -3128,4 +3116,3 @@ export function addActCompanyResponse(actId: string, input: { receivedOn: string
 }
 export function actCompanyResponseContentUrl(responseId: string) { return `${API_BASE}/act-company-responses/${responseId}/content`; }
 export function listActAdministrationCalendar(from?: string, to?: string) { const q=new URLSearchParams(); if(from)q.set('from',from); if(to)q.set('to',to); return apiRequest<{from:string;to:string;data:Array<{type:'RESPONSE_DUE'|'COMMITMENT_DUE';date:string;actId:string;actCode:string;areaName:string|null;companyName:string|null;state:ActAdministrationState}>}>(`/act-administration/calendar${q.size?`?${q}`:''}`); }
-

From 8c89cd05c9aa045ece3d957aab94c7c0ff43749a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:23:49 -0300
Subject: [PATCH 196/224] feat(f4): add explicit act lifecycle web contract

---
 web-v2/src/lib/inspectionActF4Api.ts | 204 +++++++++++++++++++++++++++
 1 file changed, 204 insertions(+)
 create mode 100644 web-v2/src/lib/inspectionActF4Api.ts

diff --git a/web-v2/src/lib/inspectionActF4Api.ts b/web-v2/src/lib/inspectionActF4Api.ts
new file mode 100644
index 0000000..e42373f
--- /dev/null
+++ b/web-v2/src/lib/inspectionActF4Api.ts
@@ -0,0 +1,204 @@
+import {
+  apiRequest,
+  type InspectionActResponsible,
+  type InspectionActSignature,
+  type InspectionActUploadMode,
+  type InspectionAssetSummary,
+  type InspectionPerson,
+  type InspectionReportPdfStatus,
+  type InspectionReportStatus,
+  type InspectionVisitStatus,
+  type PageMeta,
+} from './api';
+
+export type InspectionActStatusF4 =
+  | 'DRAFT'
+  | 'LOCKED'
+  | 'SEALED'
+  | 'CANCELLED'
+  // Valores históricos conservados sólo para lectura de registros anteriores a F4.
+  | 'READY'
+  | 'CLOSED'
+  | 'RECTIFIED';
+
+export type InspectionActVersionEventF4 =
+  | 'CREATED'
+  | 'UPDATED'
+  | 'LOCKED'
+  | 'SEALED'
+  | 'CANCELLED'
+  // Eventos históricos conservados sólo para lectura.
+  | 'READY'
+  | 'REOPENED'
+  | 'CLOSED';
+
+export type InspectionActUrgencyF4 = 'URGENT' | 'NON_URGENT';
+export type InspectionDeadlineDayTypeF4 = 'BUSINESS' | 'CALENDAR';
+export type InspectionDeadlineBasisF4 = 'ACT_DATE' | 'GEDO_DATE';
+
+export interface InspectionActListItemF4 {
+  id: string;
+  visitId: string;
+  visit: {
+    id: string;
+    code: string;
+    status: InspectionVisitStatus;
+    actualStartedAt: string | null;
+  };
+  actYear: number;
+  actNumber: number;
+  code: string;
+  status: InspectionActStatusF4;
+  occurredAt: string;
+  title: string;
+  summary: string;
+  observations: string | null;
+  urgency: InspectionActUrgencyF4;
+  deadlineDays: number | null;
+  deadlineDayType: InspectionDeadlineDayTypeF4 | null;
+  deadlineBasis: InspectionDeadlineBasisF4 | null;
+  deadlineBaseAt: string | null;
+  deadlineAt: string | null;
+  lockedAt: string | null;
+  lockedBy: string | null;
+  lockedSha256: string | null;
+  sealedAt: string | null;
+  sealedBy: string | null;
+  currentVersion: number;
+  cancellationReason: string | null;
+  closedAt: string | null;
+  closedBy: string | null;
+  closureSha256: string | null;
+  assetCount: number;
+  findingCount: number;
+  companies: Array<{ id: string; code: string; name: string }>;
+  areas: Array<{ id: string; code: string; name: string }>;
+  report: null | {
+    id: string;
+    code: string;
+    status: InspectionReportStatus;
+    pdfStatus: InspectionReportPdfStatus;
+    generatedAt: string;
+  };
+  createdBy: InspectionPerson | null;
+  updatedBy: InspectionPerson | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface InspectionActVersionF4 {
+  id: string;
+  versionNumber: number;
+  event: InspectionActVersionEventF4;
+  snapshot: Record<string, unknown>;
+  actorUserId: string | null;
+  actorUsername: string | null;
+  createdAt: string;
+}
+
+export interface InspectionActF4 extends InspectionActListItemF4 {
+  assets: InspectionAssetSummary[];
+  versions: InspectionActVersionF4[];
+}
+
+export interface InspectionClosureF4 {
+  act: {
+    id: string;
+    code: string;
+    status: InspectionActStatusF4;
+    visitId: string;
+    urgency: InspectionActUrgencyF4;
+    deadlineDays: number | null;
+    deadlineDayType: InspectionDeadlineDayTypeF4 | null;
+    deadlineBasis: InspectionDeadlineBasisF4 | null;
+    deadlineBaseAt: string | null;
+    deadlineAt: string | null;
+    lockedAt: string | null;
+    lockedSha256: string | null;
+    sealedAt: string | null;
+    currentVersion: number;
+    closedAt: string | null;
+    closedBy: string | null;
+    closureSha256: string | null;
+  };
+  visit: {
+    id: string;
+    code: string;
+    status: InspectionVisitStatus;
+    actualClosedAt: string | null;
+  };
+  responsible: InspectionActResponsible | null;
+  closure: null | {
+    schemaVersion: string;
+    preparedSha256: string;
+    preparedAt: string;
+    preparedBy: string;
+    finalSha256: string | null;
+    deviceClosedAt: string | null;
+    serverClosedAt: string | null;
+    uploadMode: InspectionActUploadMode | null;
+    closedBy: string | null;
+    isCurrent: boolean;
+  };
+  signatures: InspectionActSignature[];
+  consents: {
+    version: string;
+    inspector: string;
+    company: string;
+  };
+}
+
+export interface InspectionActPageF4 {
+  data: InspectionActListItemF4[];
+  meta: PageMeta;
+}
+
+export function listInspectionActsF4(visitId: string, params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: InspectionActStatusF4 | '';
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.status) query.set('status', params.status);
+  return apiRequest<InspectionActPageF4>(`/inspection-visits/${visitId}/acts?${query}`);
+}
+
+export function listInspectionActsGlobalF4(params: {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: InspectionActStatusF4 | '';
+  year?: number | '';
+  companyId?: string;
+  areaId?: string;
+  inspectorId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+} = {}) {
+  const query = new URLSearchParams({
+    page: String(params.page ?? 1),
+    pageSize: String(params.pageSize ?? 25),
+  });
+  if (params.search) query.set('search', params.search);
+  if (params.status) query.set('status', params.status);
+  if (params.year) query.set('year', String(params.year));
+  if (params.companyId) query.set('companyId', params.companyId);
+  if (params.areaId) query.set('areaId', params.areaId);
+  if (params.inspectorId) query.set('inspectorId', params.inspectorId);
+  if (params.dateFrom) query.set('dateFrom', params.dateFrom);
+  if (params.dateTo) query.set('dateTo', params.dateTo);
+  return apiRequest<InspectionActPageF4>(`/inspection-acts?${query}`);
+}
+
+export function getInspectionActF4(id: string) {
+  return apiRequest<InspectionActF4>(`/inspection-acts/${id}`);
+}
+
+export function getInspectionClosureF4(actId: string) {
+  return apiRequest<InspectionClosureF4>(`/inspection-acts/${actId}/closure`);
+}

From 7a406df1ad99c1453e433e7a1599434dbeae9a26 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:24:19 -0300
Subject: [PATCH 197/224] fix(f4): show locked and sealed acts in document
 center

---
 web-v2/src/pages/ActsPage.tsx | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/web-v2/src/pages/ActsPage.tsx b/web-v2/src/pages/ActsPage.tsx
index a62ef03..04a3908 100644
--- a/web-v2/src/pages/ActsPage.tsx
+++ b/web-v2/src/pages/ActsPage.tsx
@@ -8,17 +8,23 @@ import { useOperationalContext } from '../context/OperationalContext';
 import { DocumentCenterTabs } from '../features/documents/DocumentCenterTabs';
 import { inspectionActStatusClass, inspectionActStatusLabel } from '../features/inspections/inspectionActPresentation';
 import { OperationalFilters } from '../features/inspections/OperationalFilters';
-import { listInspectionActsGlobal } from '../lib/api';
-import type { InspectionActListItem, InspectionActStatus, PageMeta } from '../lib/api';
+import type { PageMeta } from '../lib/api';
+import {
+  listInspectionActsGlobalF4,
+  type InspectionActListItemF4,
+  type InspectionActStatusF4,
+} from '../lib/inspectionActF4Api';
 import { formatDate } from '../lib/format';
 
-const statuses: Array<{ value: InspectionActStatus | ''; label: string }> = [
+const statuses: Array<{ value: InspectionActStatusF4 | ''; label: string }> = [
   { value: '', label: 'Todos los estados' },
   { value: 'DRAFT', label: 'Borrador' },
-  { value: 'READY', label: 'Lista para cierre' },
-  { value: 'CLOSED', label: 'Cerrada' },
-  { value: 'RECTIFIED', label: 'Rectificada' },
+  { value: 'LOCKED', label: 'Bloqueada · esperando manifestación' },
+  { value: 'SEALED', label: 'Sellada' },
   { value: 'CANCELLED', label: 'Cancelada' },
+  { value: 'READY', label: 'Lista para cerrar · legado' },
+  { value: 'CLOSED', label: 'Cerrada · legado' },
+  { value: 'RECTIFIED', label: 'Rectificada · legado' },
 ];
 
 function contextLabel(items: Array<{ name: string }>, empty: string): string {
@@ -32,12 +38,15 @@ function contextLabel(items: Array<{ name: string }>, empty: string): string {
 export function ActsPage() {
   const [params, setParams] = useSearchParams();
   const operationalContext = useOperationalContext();
-  const [items, setItems] = useState<InspectionActListItem[]>([]);
+  const [items, setItems] = useState<InspectionActListItemF4[]>([]);
   const [meta, setMeta] = useState<PageMeta>({ page: 1, pageSize: 25, total: 0, totalPages: 0 });
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState('');
   const search = params.get('search') ?? '';
-  const status = (params.get('status') ?? '') as InspectionActStatus | '';
+  const rawStatus = params.get('status') ?? '';
+  const status = statuses.some((item) => item.value === rawStatus)
+    ? rawStatus as InspectionActStatusF4 | ''
+    : '';
   const year = params.get('year') ?? '';
   const companyId = operationalContext.companyId || params.get('companyId') || '';
   const areaId = operationalContext.areaId || params.get('areaId') || '';
@@ -50,7 +59,7 @@ export function ActsPage() {
   useEffect(() => {
     setLoading(true);
     setError('');
-    listInspectionActsGlobal({ page, pageSize: 25, search, status, year: year ? Number(year) : '', companyId, areaId, inspectorId, dateFrom, dateTo })
+    listInspectionActsGlobalF4({ page, pageSize: 25, search, status, year: year ? Number(year) : '', companyId, areaId, inspectorId, dateFrom, dateTo })
       .then((response) => {
         setItems(response.data);
         setMeta(response.meta);
@@ -108,7 +117,7 @@ export function ActsPage() {
         <td><Link className="text-link" to={`/inspecciones/${act.visitId}`}>{act.visit.code}</Link></td>
         <td><Link className="text-link" to={`/hallazgos?search=${encodeURIComponent(act.code)}`}>{act.findingCount}</Link></td>
         <td><span className={`status-badge ${inspectionActStatusClass(act.status)}`}>{inspectionActStatusLabel(act.status)}</span></td>
-        <td>{act.report ? <Link className="text-link" to={`/informes/${act.report.id}`}>{act.report.code}<small className="block-muted">{act.report.pdfStatus === 'READY' ? 'PDF disponible' : 'PDF pendiente'}</small></Link> : act.status === 'CLOSED' ? <span className="status-badge pending">Pendiente de emisión</span> : <span className="muted">—</span>}</td>
+        <td>{act.report ? <Link className="text-link" to={`/informes/${act.report.id}`}>{act.report.code}<small className="block-muted">{act.report.pdfStatus === 'READY' ? 'PDF disponible' : 'PDF pendiente'}</small></Link> : ['SEALED', 'CLOSED'].includes(act.status) ? <span className="status-badge pending">Pendiente de emisión</span> : <span className="muted">—</span>}</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 className="pagination"><button className="button secondary" disabled={page <= 1} onClick={() => setPage(page - 1)}>Anterior</button><span>{meta.total ? `${(page - 1) * meta.pageSize + 1}–${Math.min(page * meta.pageSize, meta.total)} de ${meta.total}` : '0 resultados'}</span><button className="button secondary" disabled={page >= meta.totalPages} onClick={() => setPage(page + 1)}>Siguiente</button></div>

From d8b02bfaf1008dbb1d7370bd18172ccfd77a185c Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:24:39 -0300
Subject: [PATCH 198/224] fix(f4): use act lifecycle contract inside
 inspections

---
 web-v2/src/features/inspections/InspectionActsPanel.tsx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/web-v2/src/features/inspections/InspectionActsPanel.tsx b/web-v2/src/features/inspections/InspectionActsPanel.tsx
index a8f93d9..1d24c95 100644
--- a/web-v2/src/features/inspections/InspectionActsPanel.tsx
+++ b/web-v2/src/features/inspections/InspectionActsPanel.tsx
@@ -3,8 +3,8 @@ import { Link } from 'react-router';
 import { useAuth } from '../../auth/AuthContext';
 import { Alert, EmptyState, LoadingBlock, errorMessage } from '../../components/Feedback';
 import { Icon } from '../../components/Icon';
-import { listInspectionActs } from '../../lib/api';
-import type { InspectionActListItem, InspectionVisit } from '../../lib/api';
+import type { InspectionVisit } from '../../lib/api';
+import { listInspectionActsF4, type InspectionActListItemF4 } from '../../lib/inspectionActF4Api';
 import { formatDate } from '../../lib/format';
 import { FieldBriefingPanel } from './FieldBriefingPanel';
 import { inspectionActStatusClass, inspectionActStatusLabel } from './inspectionActPresentation';
@@ -12,7 +12,7 @@ import { inspectionActStatusClass, inspectionActStatusLabel } from './inspection
 export function InspectionActsPanel({ visit }: { visit: InspectionVisit }) {
   const { hasPermission } = useAuth();
   const canRead = hasPermission('inspection_acts.read');
-  const [acts, setActs] = useState<InspectionActListItem[]>([]);
+  const [acts, setActs] = useState<InspectionActListItemF4[]>([]);
   const [loading, setLoading] = useState(canRead);
   const [error, setError] = useState('');
 
@@ -20,7 +20,7 @@ export function InspectionActsPanel({ visit }: { visit: InspectionVisit }) {
     if (!canRead) return;
     setLoading(true);
     setError('');
-    listInspectionActs(visit.id, { pageSize: 100 })
+    listInspectionActsF4(visit.id, { pageSize: 100 })
       .then((response) => setActs(response.data))
       .catch((requestError) => setError(errorMessage(requestError)))
       .finally(() => setLoading(false));

From f0ffde975b8082624a6fe8b1f0ed799ed43b96db Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:25:10 -0300
Subject: [PATCH 199/224] refactor(f4): decouple findings panel from legacy act
 type

---
 web-v2/src/features/inspections/InspectionFindingsPanel.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/web-v2/src/features/inspections/InspectionFindingsPanel.tsx b/web-v2/src/features/inspections/InspectionFindingsPanel.tsx
index c71f0ea..37ed3dc 100644
--- a/web-v2/src/features/inspections/InspectionFindingsPanel.tsx
+++ b/web-v2/src/features/inspections/InspectionFindingsPanel.tsx
@@ -4,7 +4,7 @@ import { useAuth } from '../../auth/AuthContext';
 import { Alert, EmptyState, LoadingBlock, errorMessage } from '../../components/Feedback';
 import { Icon } from '../../components/Icon';
 import { listInspectionFindings, updateInspectionFindingFollowUp } from '../../lib/api';
-import type { InspectionAct, InspectionFinding } from '../../lib/api';
+import type { InspectionFinding } from '../../lib/api';
 import { formatDateOnly } from '../../lib/format';
 import { InspectionEvidencePanel } from './InspectionEvidencePanel';
 
@@ -84,7 +84,7 @@ function FindingCard({
   </article>;
 }
 
-export function InspectionFindingsPanel({ act }: { act: InspectionAct }) {
+export function InspectionFindingsPanel({ act }: { act: { id: string } }) {
   const { hasPermission } = useAuth();
   const canRead = hasPermission('inspection_findings.read');
   const [findings, setFindings] = useState<InspectionFinding[]>([]);

From b67db745e4730f9190edff4b6c4415187ef3300a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:25:46 -0300
Subject: [PATCH 200/224] fix(f4): present locked and sealed act lifecycle

---
 .../inspections/InspectionClosurePanel.tsx    | 46 ++++++++++++++-----
 1 file changed, 34 insertions(+), 12 deletions(-)

diff --git a/web-v2/src/features/inspections/InspectionClosurePanel.tsx b/web-v2/src/features/inspections/InspectionClosurePanel.tsx
index 1fc3a90..9984f33 100644
--- a/web-v2/src/features/inspections/InspectionClosurePanel.tsx
+++ b/web-v2/src/features/inspections/InspectionClosurePanel.tsx
@@ -2,8 +2,13 @@ import { useEffect, useMemo, useState } from 'react';
 import { useAuth } from '../../auth/AuthContext';
 import { Alert, LoadingBlock, errorMessage } from '../../components/Feedback';
 import { Icon } from '../../components/Icon';
-import { getInspectionClosure, getInspectionSignatureBlob } from '../../lib/api';
-import type { InspectionAct, InspectionActSignature, InspectionClosure } from '../../lib/api';
+import { getInspectionSignatureBlob } from '../../lib/api';
+import type { InspectionActSignature } from '../../lib/api';
+import {
+  getInspectionClosureF4,
+  type InspectionActF4,
+  type InspectionClosureF4,
+} from '../../lib/inspectionActF4Api';
 import { formatDate } from '../../lib/format';
 
 function signatureStatusLabel(value: InspectionActSignature['status']): string {
@@ -16,17 +21,17 @@ function signerTypeLabel(value: InspectionActSignature['signerType']): string {
   return value === 'INSPECTOR' ? 'Inspector/a' : 'Responsable de la empresa';
 }
 
-export function InspectionClosurePanel({ act }: { act: InspectionAct }) {
+export function InspectionClosurePanel({ act }: { act: InspectionActF4 }) {
   const { hasPermission } = useAuth();
   const canRead = hasPermission('inspection_closure.read');
-  const [closure, setClosure] = useState<InspectionClosure | null>(null);
+  const [closure, setClosure] = useState<InspectionClosureF4 | null>(null);
   const [loading, setLoading] = useState(canRead);
   const [error, setError] = useState('');
 
   useEffect(() => {
     if (!canRead) return;
     setLoading(true);
-    getInspectionClosure(act.id)
+    getInspectionClosureF4(act.id)
       .then(setClosure)
       .catch((requestError) => setError(errorMessage(requestError)))
       .finally(() => setLoading(false));
@@ -60,26 +65,43 @@ export function InspectionClosurePanel({ act }: { act: InspectionAct }) {
   if (loading || !closure) return <section className="panel inspection-closure-panel"><LoadingBlock label="Cargando cierre del acta…" /></section>;
 
   const constanciasCompletas = inspectorSignatures.length > 0 && Boolean(companyOutcome);
+  const isSealed = act.status === 'SEALED' || act.status === 'CLOSED';
+  const isLocked = act.status === 'LOCKED' || act.status === 'READY';
+  const lifecycleLabel = isSealed
+    ? 'Acta sellada'
+    : isLocked
+      ? 'Esperando manifestación'
+      : act.status === 'CANCELLED'
+        ? 'Acta cancelada'
+        : 'Borrador en campo';
+  const lifecycleClass = isSealed ? 'active' : isLocked ? 'observed' : act.status === 'CANCELLED' ? 'inactive' : 'pending';
 
   return <section className="panel inspection-closure-panel">
-    <div className="panel-heading"><div><span className="eyebrow">CIERRE DEL ACTA · SÓLO LECTURA</span><h2>Responsable, firmas y sellado</h2><p className="section-copy">La preparación y firma del acta se realizan desde la APK. La inspección puede continuar con otras actas.</p></div><span className={`status-badge large ${act.status === 'CLOSED' ? 'active' : act.status === 'READY' ? 'observed' : 'pending'}`}>{act.status === 'CLOSED' ? 'Cierre sellado' : act.status === 'READY' ? 'Esperando firmas' : 'Pendiente en APK'}</span></div>
+    <div className="panel-heading"><div><span className="eyebrow">CIERRE DEL ACTA · SÓLO LECTURA</span><h2>Responsable, firmas y sellado</h2><p className="section-copy">Al bloquearse, el contenido del Acta queda inmutable. La Inspección puede continuar y generar otras Actas.</p></div><span className={`status-badge large ${lifecycleClass}`}>{lifecycleLabel}</span></div>
 
     {error && <Alert>{error}</Alert>}
-    <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Operación exclusiva en APK.</strong> El dashboard muestra las constancias sincronizadas, pero no permite identificar al responsable, firmar, reabrir ni cerrar el acta.</p></div>
+    <div className="temporal-notice"><Icon name="clipboard" /><p><strong>El dashboard no modifica el Acta.</strong> El bloqueo y la firma del Inspector se realizan desde la APK. La manifestación de la empresa puede completarse en campo o mediante el enlace seguro posterior.</p></div>
 
     <div className="closure-step-grid">
       <div className={closure.responsible ? 'complete' : ''}><span>1</span><strong>Responsable</strong><small>{closure.responsible ? 'Registrado' : 'Pendiente'}</small></div>
-      <div className={closure.closure?.isCurrent ? 'complete' : ''}><span>2</span><strong>Congelado</strong><small>{closure.closure?.isCurrent ? 'SHA-256 listo' : 'Pendiente'}</small></div>
-      <div className={constanciasCompletas ? 'complete' : ''}><span>3</span><strong>Constancias</strong><small>{inspectorSignatures.length} inspector · {companyOutcome ? 'empresa OK' : 'empresa pendiente'}</small></div>
-      <div className={act.status === 'CLOSED' ? 'complete' : ''}><span>4</span><strong>Cierre</strong><small>{act.status === 'CLOSED' ? 'Sellado' : 'Pendiente'}</small></div>
+      <div className={closure.closure?.isCurrent ? 'complete' : ''}><span>2</span><strong>Bloqueo</strong><small>{closure.closure?.isCurrent ? 'Contenido inmutable' : 'Pendiente'}</small></div>
+      <div className={constanciasCompletas ? 'complete' : ''}><span>3</span><strong>Manifestaciones</strong><small>{inspectorSignatures.length} inspector · {companyOutcome ? 'empresa resuelta' : 'empresa pendiente'}</small></div>
+      <div className={isSealed ? 'complete' : ''}><span>4</span><strong>Sellado</strong><small>{isSealed ? 'Definitivo' : 'Pendiente'}</small></div>
+    </div>
+
+    <div className="responsible-summary">
+      <div><small>Urgencia</small><strong>{closure.act.urgency === 'URGENT' ? 'Urgente' : 'No urgente'}</strong></div>
+      <div><small>Plazo configurado</small><strong>{closure.act.deadlineDays ? `${closure.act.deadlineDays} días ${closure.act.deadlineDayType === 'BUSINESS' ? 'hábiles' : 'corridos'}` : 'Pendiente'}</strong></div>
+      <div><small>Inicio del plazo</small><strong>{closure.act.deadlineBaseAt ? formatDate(closure.act.deadlineBaseAt) : 'Pendiente de evento válido'}</strong></div>
+      <div><small>Vencimiento</small><strong>{closure.act.deadlineAt ? formatDate(closure.act.deadlineAt) : 'Todavía no iniciado'}</strong></div>
     </div>
 
     {closure.responsible && <div className="responsible-summary"><div><small>Situación</small><strong>{closure.responsible.attendanceStatus === 'PRESENT' ? 'Presente' : 'Ausente'}</strong></div><div><small>Responsable</small><strong>{closure.responsible.fullName ?? 'No estuvo presente'}</strong></div><div><small>Documento / cargo</small><strong>{closure.responsible.documentNumber ? `${closure.responsible.documentType} ${closure.responsible.documentNumber}` : 'No informado'}{closure.responsible.position ? ` · ${closure.responsible.position}` : ''}</strong></div><div><small>Contacto</small><strong>{closure.responsible.email ?? closure.responsible.phone ?? 'No informado'}</strong></div></div>}
 
-    {closure.closure?.isCurrent && <div className="closure-hash-card"><div><span className="eyebrow">CONTENIDO CONGELADO</span><strong>{closure.closure.schemaVersion}</strong><small>Preparado {formatDate(closure.closure.preparedAt)}</small></div><code>{closure.closure.preparedSha256}</code></div>}
+    {closure.closure?.isCurrent && <div className="closure-hash-card"><div><span className="eyebrow">CONTENIDO BLOQUEADO</span><strong>{closure.closure.schemaVersion}</strong><small>Bloqueado {formatDate(closure.act.lockedAt ?? closure.closure.preparedAt)}</small></div><code>{closure.act.lockedSha256 ?? closure.closure.preparedSha256}</code></div>}
 
     {closure.signatures.length > 0 && <div className="signature-records">{closure.signatures.map((signature) => <article key={signature.id}><div><span className={`status-badge ${signature.status === 'SIGNED' ? 'active' : 'observed'}`}>{signatureStatusLabel(signature.status)}</span><strong>{signature.signerName}</strong><small>{signerTypeLabel(signature.signerType)} · {formatDate(signature.createdAt)}</small></div><code title={signature.signaturePayloadSha256}>{signature.signaturePayloadSha256}</code>{signature.status === 'SIGNED' ? <><button type="button" className="button secondary" onClick={() => viewSignature(signature)}>Ver firma</button>{signature.signerType === 'COMPANY_RESPONSIBLE' && <p><strong>{signature.companyManifestation === 'DISSENT' ? 'Firma en disidencia' : 'Firma en conformidad'}</strong>{signature.companyStatement ? ` · ${signature.companyStatement}` : ''}</p>}</> : <p>{signature.reason}</p>}</article>)}</div>}
 
-    {act.status === 'CLOSED' && closure.closure?.finalSha256 && <div className="closed-seal"><Icon name="check" /><div><span className="eyebrow">ACTA CERRADA</span><strong>{formatDate(closure.closure.serverClosedAt)}</strong><p>El acta quedó sellada. La inspección y las demás actas tienen un ciclo independiente.</p><code>{closure.closure.finalSha256}</code></div></div>}
+    {isSealed && closure.closure?.finalSha256 && <div className="closed-seal"><Icon name="check" /><div><span className="eyebrow">ACTA SELLADA</span><strong>{formatDate(closure.act.sealedAt ?? closure.closure.serverClosedAt)}</strong><p>El Acta quedó sellada e inmutable. La Inspección y sus demás Actas continúan con ciclo independiente.</p><code>{closure.closure.finalSha256}</code></div></div>}
   </section>;
 }

From b3125b51adaf62bb6b32f64ceb5cbcff76cc714f Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:26:13 -0300
Subject: [PATCH 201/224] fix(f4): use locked sealed lifecycle in act detail

---
 web-v2/src/pages/InspectionActEditorPage.tsx | 23 +++++++++++---------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/web-v2/src/pages/InspectionActEditorPage.tsx b/web-v2/src/pages/InspectionActEditorPage.tsx
index e57e9f4..d9199fa 100644
--- a/web-v2/src/pages/InspectionActEditorPage.tsx
+++ b/web-v2/src/pages/InspectionActEditorPage.tsx
@@ -9,14 +9,15 @@ import {
 } from '../features/inspections/inspectionActPresentation';
 import { InspectionClosurePanel } from '../features/inspections/InspectionClosurePanel';
 import { InspectionFindingsPanel } from '../features/inspections/InspectionFindingsPanel';
-import { getInspectionAct, getInspectionVisit } from '../lib/api';
-import type { InspectionAct, InspectionVisit } from '../lib/api';
+import { getInspectionVisit } from '../lib/api';
+import type { InspectionVisit } from '../lib/api';
+import { getInspectionActF4, type InspectionActF4 } from '../lib/inspectionActF4Api';
 import { formatDate } from '../lib/format';
 
 export function InspectionActEditorPage() {
   const { actId } = useParams();
   const [visit, setVisit] = useState<InspectionVisit | null>(null);
-  const [act, setAct] = useState<InspectionAct | null>(null);
+  const [act, setAct] = useState<InspectionActF4 | null>(null);
   const [loading, setLoading] = useState(Boolean(actId));
   const [error, setError] = useState('');
 
@@ -24,7 +25,7 @@ export function InspectionActEditorPage() {
     if (!actId) return;
     setLoading(true);
     setError('');
-    getInspectionAct(actId)
+    getInspectionActF4(actId)
       .then(async (value) => {
         setAct(value);
         setVisit(await getInspectionVisit(value.visitId));
@@ -36,22 +37,24 @@ export function InspectionActEditorPage() {
   if (!actId) {
     return <section className="survey-editor inspection-act-editor">
       <div className="breadcrumb"><Link to="/inspecciones">Inspecciones</Link><span>/</span><span>Acta</span></div>
-      <div className="page-heading"><div><span className="eyebrow">OPERACIÓN EXCLUSIVA EN APK</span><h1>Crear acta de inspección</h1><p>Las actas sólo pueden generarse durante la visita física desde la aplicación móvil.</p></div></div>
-      <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Usá la APK con un usuario inspector.</strong> El dashboard recibirá el acta, sus hallazgos y firmas cuando la aplicación sincronice.</p></div>
+      <div className="page-heading"><div><span className="eyebrow">OPERACIÓN EXCLUSIVA EN APK</span><h1>Crear acta de inspección</h1><p>Las actas sólo pueden generarse durante la inspección física desde la aplicación móvil.</p></div></div>
+      <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Usá la APK con un usuario inspector.</strong> El dashboard recibirá el Acta, sus Hallazgos y constancias cuando la aplicación sincronice.</p></div>
       <Link className="button secondary" to="/inspecciones">Volver a inspecciones</Link>
     </section>;
   }
 
   if (loading) return <LoadingBlock label="Cargando acta…" />;
 
+  const isSealed = act?.status === 'SEALED' || act?.status === 'CLOSED';
+
   return <section className="survey-editor inspection-act-editor">
     <div className="breadcrumb"><Link to="/inspecciones">Inspecciones</Link><span>/</span>{visit && <><Link to={`/inspecciones/${visit.id}`}>{visit.code}</Link><span>/</span></>}<span>{act?.code ?? 'Acta'}</span></div>
     <div className="page-heading survey-editor-heading"><div><span className="eyebrow">ACTA DE INSPECCIÓN · SÓLO LECTURA</span><h1>{act?.title ?? 'Acta'}</h1><p>{act ? `${act.code} · versión ${act.currentVersion}` : 'Consulta del documento sincronizado desde la APK.'}</p></div>{act && <span className={`status-badge large ${inspectionActStatusClass(act.status)}`}>{inspectionActStatusLabel(act.status)}</span>}</div>
 
     {error && <Alert>{error}</Alert>}
-    {visit && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>{visit.code}</strong> El contenido constatado, los hallazgos y el cierre se registran exclusivamente desde la APK. Este dashboard permite consultarlos y gestionar el seguimiento posterior.</p></div>}
+    {visit && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>{visit.code}</strong> El contenido constatado y los Hallazgos se registran desde la APK. Una vez bloqueada, el Acta ya no vuelve a borrador; la manifestación de empresa puede completarse posteriormente por enlace seguro.</p></div>}
     {act?.report && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Informe relacionado: <Link to={`/informes/${act.report.id}`}>{act.report.code}</Link>.</strong> {act.report.pdfStatus === 'READY' ? 'El documento PDF está disponible.' : 'El contenido está congelado y el PDF continúa pendiente de composición.'}</p></div>}
-    {act?.status === 'CLOSED' && !act.report && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Informe pendiente de emisión.</strong> La solicitud se realiza desde la APK por un inspector asignado a la visita.</p></div>}
+    {isSealed && act && !act.report && <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Informe pendiente de emisión.</strong> El Acta ya está sellada y habilita el circuito documental del INF.</p></div>}
     {act?.status === 'CANCELLED' && <Alert>Cancelada: {act.cancellationReason}</Alert>}
 
     {act && <section className="panel inspection-act-form">
@@ -59,7 +62,7 @@ export function InspectionActEditorPage() {
       <div className="responsible-summary">
         <div><small>Fecha y hora</small><strong>{formatDate(act.occurredAt)}</strong></div>
         <div><small>Título</small><strong>{act.title}</strong></div>
-        <div><small>Registros</small><strong>{act.assets.length}</strong></div>
+        <div><small>Urgencia</small><strong>{act.urgency === 'URGENT' ? 'Urgente' : 'No urgente'}</strong></div>
         <div><small>Hallazgos</small><strong>{act.findingCount}</strong></div>
       </div>
       <div className="closure-section"><span className="eyebrow">DESCRIPCIÓN DE LO ACTUADO</span><p>{act.summary}</p>{act.observations && <><span className="eyebrow">OBSERVACIONES</span><p>{act.observations}</p></>}</div>
@@ -71,7 +74,7 @@ export function InspectionActEditorPage() {
     {act && <InspectionClosurePanel act={act} />}
 
     {act && <section className="panel survey-report-history">
-      <div className="panel-heading"><div><span className="eyebrow">VERSIONES INMUTABLES</span><h2>Historial exacto del acta</h2><p className="section-copy">Cada sincronización conserva el contenido y las versiones de los registros referenciados.</p></div><span className="count-pill">{act.versions.length}</span></div>
+      <div className="panel-heading"><div><span className="eyebrow">VERSIONES INMUTABLES</span><h2>Historial exacto del acta</h2><p className="section-copy">Cada transición conserva el contenido y las versiones de los registros referenciados.</p></div><span className="count-pill">{act.versions.length}</span></div>
       <div className="survey-version-list">{act.versions.map((version) => <details key={version.id}><summary><span className="count-pill">v{version.versionNumber}</span><strong>{inspectionActVersionEventLabel(version.event)}</strong><small>{formatDate(version.createdAt)} · {version.actorUsername ?? 'sistema'}</small></summary><pre>{JSON.stringify(version.snapshot, null, 2)}</pre></details>)}</div>
     </section>}
   </section>;

From d0b805b28119dc7345eef68d0f6329a96c084574 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:26:51 -0300
Subject: [PATCH 202/224] test(f4): guard locked sealed web act lifecycle

---
 .../f4-act-web-lifecycle-contract.test.ts     | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 api-v3/test/unit/f4-act-web-lifecycle-contract.test.ts

diff --git a/api-v3/test/unit/f4-act-web-lifecycle-contract.test.ts b/api-v3/test/unit/f4-act-web-lifecycle-contract.test.ts
new file mode 100644
index 0000000..fd6a50e
--- /dev/null
+++ b/api-v3/test/unit/f4-act-web-lifecycle-contract.test.ts
@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = process.cwd();
+const readWeb = (relative: string) => fs.readFileSync(path.join(root, '..', 'web-v2', 'src', relative), 'utf8');
+
+const f4Api = readWeb('lib/inspectionActF4Api.ts');
+const actsPage = readWeb('pages/ActsPage.tsx');
+const actsPanel = readWeb('features/inspections/InspectionActsPanel.tsx');
+const actDetail = readWeb('pages/InspectionActEditorPage.tsx');
+const closurePanel = readWeb('features/inspections/InspectionClosurePanel.tsx');
+const presentation = readWeb('features/inspections/inspectionActPresentation.ts');
+
+test('F4 WEB has an explicit LOCKED and SEALED act contract', () => {
+  assert.match(f4Api, /export type InspectionActStatusF4/);
+  assert.match(f4Api, /\| 'LOCKED'/);
+  assert.match(f4Api, /\| 'SEALED'/);
+  assert.match(f4Api, /lockedAt: string \| null/);
+  assert.match(f4Api, /lockedSha256: string \| null/);
+  assert.match(f4Api, /sealedAt: string \| null/);
+  assert.match(f4Api, /urgency: InspectionActUrgencyF4/);
+  assert.match(f4Api, /deadlineAt: string \| null/);
+});
+
+test('F4 document center and inspection detail consume the F4 act client', () => {
+  assert.match(actsPage, /listInspectionActsGlobalF4/);
+  assert.match(actsPage, /value: 'LOCKED'/);
+  assert.match(actsPage, /value: 'SEALED'/);
+  assert.match(actsPanel, /listInspectionActsF4/);
+  assert.match(actDetail, /getInspectionActF4/);
+  assert.match(actDetail, /act\?\.status === 'SEALED'/);
+});
+
+test('F4 closure UI treats sealing as the definitive act state', () => {
+  assert.match(closurePanel, /getInspectionClosureF4/);
+  assert.match(closurePanel, /act\.status === 'SEALED'/);
+  assert.match(closurePanel, /ACTA SELLADA/);
+  assert.match(closurePanel, /manifestación de la empresa puede completarse/);
+  assert.match(closurePanel, /Pendiente de evento válido/);
+  assert.doesNotMatch(closurePanel, /reabrir ni cerrar el acta/);
+});
+
+test('F4 presentation keeps new lifecycle labels while retaining explicit legacy readability', () => {
+  assert.match(presentation, /LOCKED: 'Bloqueada/);
+  assert.match(presentation, /SEALED: 'Sellada'/);
+  assert.match(presentation, /READY: 'Lista para cerrar · legado'/);
+  assert.match(presentation, /CLOSED: 'Cerrada · legado'/);
+});

From fa64ba772704d1a0bb7aab14a9cd9c0136fe9138 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:27:32 -0300
Subject: [PATCH 203/224] fix(f4): align embedded INF status in act contract

---
 web-v2/src/lib/inspectionActF4Api.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/web-v2/src/lib/inspectionActF4Api.ts b/web-v2/src/lib/inspectionActF4Api.ts
index e42373f..e4da94c 100644
--- a/web-v2/src/lib/inspectionActF4Api.ts
+++ b/web-v2/src/lib/inspectionActF4Api.ts
@@ -6,7 +6,6 @@ import {
   type InspectionAssetSummary,
   type InspectionPerson,
   type InspectionReportPdfStatus,
-  type InspectionReportStatus,
   type InspectionVisitStatus,
   type PageMeta,
 } from './api';
@@ -35,6 +34,7 @@ export type InspectionActVersionEventF4 =
 export type InspectionActUrgencyF4 = 'URGENT' | 'NON_URGENT';
 export type InspectionDeadlineDayTypeF4 = 'BUSINESS' | 'CALENDAR';
 export type InspectionDeadlineBasisF4 = 'ACT_DATE' | 'GEDO_DATE';
+export type InspectionReportStatusF4 = 'WORKING' | 'OFFICIALIZED' | 'FROZEN' | 'CANCELLED';
 
 export interface InspectionActListItemF4 {
   id: string;
@@ -76,7 +76,7 @@ export interface InspectionActListItemF4 {
   report: null | {
     id: string;
     code: string;
-    status: InspectionReportStatus;
+    status: InspectionReportStatusF4;
     pdfStatus: InspectionReportPdfStatus;
     generatedAt: string;
   };

From 27d14d2d4e9085abd9471ad42ef093f57b9e3f57 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:29:24 -0300
Subject: [PATCH 204/224] refactor(f4): remove legacy mobile act lifecycle
 aliases

---
 .../com/korexlabs/dhinspeccion/data/MobileActs.kt     | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
index 3691826..49ca613 100644
--- a/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
+++ b/android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/MobileActs.kt
@@ -367,14 +367,6 @@ class MobileActsRepository(context: Context) {
         api.lock("Bearer ${session.accessToken}", actId)
     }
 
-    /** Transitional alias used only while the F4 screen migration is in this branch. */
-    suspend fun prepare(actId: String): MobileActClosure = lock(actId)
-
-    /** F4 does not allow reopening an Act once it has been locked. */
-    suspend fun reopen(@Suppress("UNUSED_PARAMETER") actId: String): MobileActClosure {
-        throw IllegalStateException("Un Acta finalizada es inmutable y no puede volver a borrador")
-    }
-
     suspend fun signInspector(
         actId: String,
         png: File,
@@ -414,9 +406,6 @@ class MobileActsRepository(context: Context) {
         api.sealAct("Bearer ${session.accessToken}", actId, MobileSealActRequest())
     }
 
-    /** Transitional alias used only while the F4 screen migration is in this branch. */
-    suspend fun closeAct(actId: String): MobileActClosure = seal(actId)
-
     suspend fun closeVisit(visitId: String): VisitDetail = authorized { session ->
         api.closeVisit("Bearer ${session.accessToken}", visitId, MobileCloseVisitRequest())
     }

From 0442511065b4f4b4fc2ae240949fec6cf47e3287 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:29:42 -0300
Subject: [PATCH 205/224] test(f4): guard android lock seal lifecycle contract

---
 .../test/unit/f4-android-act-contract.test.ts | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 api-v3/test/unit/f4-android-act-contract.test.ts

diff --git a/api-v3/test/unit/f4-android-act-contract.test.ts b/api-v3/test/unit/f4-android-act-contract.test.ts
new file mode 100644
index 0000000..f50fcd8
--- /dev/null
+++ b/api-v3/test/unit/f4-android-act-contract.test.ts
@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = process.cwd();
+const android = (...segments: string[]) => path.join(root, '..', 'android-app', 'app', 'src', 'main', 'java', 'com', 'korexlabs', 'dhinspeccion', ...segments);
+const read = (...segments: string[]) => fs.readFileSync(android(...segments), 'utf8');
+
+const mobileCore = read('data', 'DhMobile.kt');
+const mobileActs = read('data', 'MobileActs.kt');
+const viewModel = read('MainViewModel.kt');
+
+test('F4 Android inspection contract has no title or planned end field', () => {
+  const summary = mobileCore.slice(mobileCore.indexOf('data class VisitSummary('), mobileCore.indexOf('data class VisitMeta('));
+  const detail = mobileCore.slice(mobileCore.indexOf('data class VisitDetail('), mobileCore.indexOf('// ---------- Field inventory ----------'));
+
+  assert.doesNotMatch(summary, /\btitle\s*:/);
+  assert.doesNotMatch(summary, /\bplannedEndAt\b/);
+  assert.doesNotMatch(detail, /\btitle\s*:/);
+  assert.doesNotMatch(detail, /\bplannedEndAt\b/);
+  assert.match(summary, /plannedStartAt/);
+  assert.match(detail, /plannedStartAt/);
+});
+
+test('F4 Android uses only lock and seal endpoints for the active Act lifecycle', () => {
+  assert.match(mobileActs, /inspection-acts\/\{actId\}\/lock/);
+  assert.match(mobileActs, /inspection-acts\/\{actId\}\/seal/);
+  assert.doesNotMatch(mobileActs, /inspection-acts\/\{actId\}\/ready/);
+  assert.doesNotMatch(mobileActs, /inspection-acts\/\{actId\}\/reopen/);
+  assert.doesNotMatch(mobileActs, /inspection-acts\/\{actId\}\/close["']/);
+  assert.doesNotMatch(mobileActs, /suspend fun prepare\(/);
+  assert.doesNotMatch(mobileActs, /suspend fun reopen\(/);
+  assert.doesNotMatch(mobileActs, /suspend fun closeAct\(/);
+});
+
+test('F4 Android ViewModel calls lock and seal directly', () => {
+  assert.match(viewModel, /actsRepository\.lock\(actId\)/);
+  assert.match(viewModel, /actsRepository\.seal\(actId\)/);
+  assert.doesNotMatch(viewModel, /actsRepository\.prepare\(/);
+  assert.doesNotMatch(viewModel, /actsRepository\.reopen\(/);
+  assert.doesNotMatch(viewModel, /actsRepository\.closeAct\(/);
+});

From 9606168ac6829965a32b7ababcb9347bfdd1a92b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:30:27 -0300
Subject: [PATCH 206/224] fix(f4): make inspection legacy field removal data
 reversible

---
 ...0000-f4-remove-inspection-legacy-fields.ts | 53 ++++++++++++++++---
 1 file changed, 47 insertions(+), 6 deletions(-)

diff --git a/api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts b/api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts
index 4555137..55f62fb 100644
--- a/api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts
+++ b/api-v3/src/database/migrations/1790000500000-f4-remove-inspection-legacy-fields.ts
@@ -5,13 +5,44 @@ import { MigrationInterface, QueryRunner } from 'typeorm';
  * - title: la Inspección se identifica por su código autogenerado.
  * - planned_end_at: la planificación sólo define la fecha/hora prevista de inicio.
  *
+ * La migración conserva una copia técnica de los valores eliminados para que un
+ * rollback restaure los datos exactos existentes antes del cambio. Inspecciones
+ * creadas después del up() reciben code como title y planned_end_at NULL al bajar.
+ *
  * Se conserva un índice sobre planned_start_at porque sigue siendo un criterio de
- * orden y filtro operativo. El rollback reconstruye la forma original de D1.
+ * orden y filtro operativo. Ninguna migración histórica se modifica.
  */
 export class F4RemoveInspectionLegacyFields1790000500000 implements MigrationInterface {
   name = 'F4RemoveInspectionLegacyFields1790000500000';
 
   public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS f4_inspection_visit_legacy_fields_backup (
+        visit_id uuid PRIMARY KEY,
+        title varchar(200) NOT NULL,
+        planned_end_at timestamptz NULL,
+        backed_up_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await queryRunner.query(`
+      INSERT INTO f4_inspection_visit_legacy_fields_backup (
+        visit_id,
+        title,
+        planned_end_at,
+        backed_up_at
+      )
+      SELECT
+        id,
+        title,
+        planned_end_at,
+        CURRENT_TIMESTAMP
+      FROM inspection_visits
+      ON CONFLICT (visit_id) DO UPDATE SET
+        title = EXCLUDED.title,
+        planned_end_at = EXCLUDED.planned_end_at,
+        backed_up_at = EXCLUDED.backed_up_at
+    `);
+
     await queryRunner.query(`DROP INDEX IF EXISTS idx_inspection_visits_planned_dates`);
     await queryRunner.query(`
       ALTER TABLE inspection_visits
@@ -34,6 +65,19 @@ export class F4RemoveInspectionLegacyFields1790000500000 implements MigrationInt
       ALTER TABLE inspection_visits
       ADD COLUMN IF NOT EXISTS title varchar(200)
     `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_visits
+      ADD COLUMN IF NOT EXISTS planned_end_at timestamptz
+    `);
+
+    await queryRunner.query(`
+      UPDATE inspection_visits visit
+      SET
+        title = backup.title,
+        planned_end_at = backup.planned_end_at
+      FROM f4_inspection_visit_legacy_fields_backup backup
+      WHERE backup.visit_id = visit.id
+    `);
     await queryRunner.query(`
       UPDATE inspection_visits
       SET title = code
@@ -44,11 +88,6 @@ export class F4RemoveInspectionLegacyFields1790000500000 implements MigrationInt
       ALTER COLUMN title SET NOT NULL
     `);
 
-    await queryRunner.query(`
-      ALTER TABLE inspection_visits
-      ADD COLUMN IF NOT EXISTS planned_end_at timestamptz
-    `);
-
     await queryRunner.query(`
       DO $$
       BEGIN
@@ -73,5 +112,7 @@ export class F4RemoveInspectionLegacyFields1790000500000 implements MigrationInt
       CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_dates
       ON inspection_visits (planned_start_at, planned_end_at)
     `);
+
+    await queryRunner.query(`DROP TABLE IF EXISTS f4_inspection_visit_legacy_fields_backup`);
   }
 }

From a510d309bc48c21c6e83a097a5718e4b8b86f386 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 10:30:53 -0300
Subject: [PATCH 207/224] test(f4): prove legacy field rollback preserves data

---
 .../unit/f4-inspection-legacy-fields.test.ts  | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
index 54027ac..683764d 100644
--- a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
+++ b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
@@ -55,7 +55,7 @@ test('F4: el contrato WEB de Inspecciones no reintroduce title, visitTitle ni pl
   assert.doesNotMatch(inspectionContract, /\bplannedEndAt\b/);
 });
 
-test('F4: la migración retira las columnas legacy y conserva índice de inicio', async () => {
+test('F4: la migración respalda datos antes de retirar columnas legacy', async () => {
   const statements: string[] = [];
   const queryRunner = {
     query: async (sql: string) => {
@@ -67,14 +67,21 @@ test('F4: la migración retira las columnas legacy y conserva índice de inicio'
   await new F4RemoveInspectionLegacyFields1790000500000().up(queryRunner);
   const sql = statements.join('\n');
 
+  assert.match(sql, /CREATE TABLE IF NOT EXISTS f4_inspection_visit_legacy_fields_backup/i);
+  assert.match(sql, /INSERT INTO f4_inspection_visit_legacy_fields_backup/i);
+  assert.match(sql, /SELECT id, title, planned_end_at, CURRENT_TIMESTAMP FROM inspection_visits/i);
   assert.match(sql, /DROP COLUMN IF EXISTS planned_end_at/i);
   assert.match(sql, /DROP COLUMN IF EXISTS title/i);
   assert.match(sql, /DROP CONSTRAINT IF EXISTS chk_inspection_visits_planned_dates/i);
   assert.match(sql, /CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_start_at/i);
   assert.doesNotMatch(sql, /CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_dates/i);
+
+  const backupAt = sql.indexOf('INSERT INTO f4_inspection_visit_legacy_fields_backup');
+  const dropAt = sql.indexOf('DROP COLUMN IF EXISTS planned_end_at');
+  assert.ok(backupAt >= 0 && dropAt > backupAt, 'el respaldo debe ocurrir antes de eliminar columnas');
 });
 
-test('F4: el rollback reconstruye la forma histórica de D1', async () => {
+test('F4: el rollback restaura valores históricos exactos y cubre filas nuevas', async () => {
   const statements: string[] = [];
   const queryRunner = {
     query: async (sql: string) => {
@@ -87,9 +94,15 @@ test('F4: el rollback reconstruye la forma histórica de D1', async () => {
   const sql = statements.join('\n');
 
   assert.match(sql, /ADD COLUMN IF NOT EXISTS title varchar\(200\)/i);
+  assert.match(sql, /ADD COLUMN IF NOT EXISTS planned_end_at timestamptz/i);
+  assert.match(sql, /UPDATE inspection_visits visit SET title = backup\.title, planned_end_at = backup\.planned_end_at FROM f4_inspection_visit_legacy_fields_backup backup WHERE backup\.visit_id = visit\.id/i);
   assert.match(sql, /UPDATE inspection_visits SET title = code WHERE title IS NULL/i);
   assert.match(sql, /ALTER COLUMN title SET NOT NULL/i);
-  assert.match(sql, /ADD COLUMN IF NOT EXISTS planned_end_at timestamptz/i);
   assert.match(sql, /ADD CONSTRAINT chk_inspection_visits_planned_dates CHECK/i);
   assert.match(sql, /CREATE INDEX IF NOT EXISTS idx_inspection_visits_planned_dates/i);
+  assert.match(sql, /DROP TABLE IF EXISTS f4_inspection_visit_legacy_fields_backup/i);
+
+  const restoreAt = sql.indexOf('UPDATE inspection_visits visit SET title = backup.title');
+  const backupDropAt = sql.indexOf('DROP TABLE IF EXISTS f4_inspection_visit_legacy_fields_backup');
+  assert.ok(restoreAt >= 0 && backupDropAt > restoreAt, 'el respaldo sólo se elimina después de restaurar los datos');
 });

From 4d0ed8b0464546a66ea2bb6a4fd58ff10e552f87 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 11:41:42 -0300
Subject: [PATCH 208/224] test(f4): guard all active inspection consumers from
 legacy fields

---
 .../unit/f4-inspection-legacy-fields.test.ts  | 22 ++++++++++++-------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
index 683764d..47e9508 100644
--- a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
+++ b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
@@ -25,15 +25,21 @@ test('F4: InspectionVisit no vuelve a mapear title ni plannedEndAt', () => {
   assert.equal(indexes.includes('idx_inspection_visits_planned_start_at'), true);
 });
 
-test('F4: los consumidores backend activos no consultan el title físico de la Inspección', () => {
-  const acts = read('src/inspection-acts/inspection-acts.service.ts');
-  const findings = read('src/inspection-findings/inspection-findings.service.ts');
+test('F4: los consumidores backend activos no consultan campos físicos legacy de la Inspección', () => {
+  const consumers = [
+    read('src/inspection-acts/inspection-acts.service.ts'),
+    read('src/inspection-findings/inspection-findings.service.ts'),
+    read('src/inspection-findings/inspection-finding-worklist.service.ts'),
+    read('src/inspection-verifications/inspection-verifications.service.ts'),
+    read('src/asset-master/assets.service.ts'),
+  ];
 
-  assert.doesNotMatch(acts, /visit\.title/);
-  assert.doesNotMatch(acts, /['"]title['"]\s*,\s*visit\.title/);
-  assert.doesNotMatch(findings, /visit\.title/);
-  assert.doesNotMatch(findings, /verification_target\.title/);
-  assert.doesNotMatch(findings, /visitTitle/);
+  for (const consumer of consumers) {
+    assert.doesNotMatch(consumer, /visit\.title/);
+    assert.doesNotMatch(consumer, /verification_target\.title/);
+    assert.doesNotMatch(consumer, /\bvisitTitle\b/);
+    assert.doesNotMatch(consumer, /\bplanned_end_at\b/);
+  }
 });
 
 test('F4: el contrato WEB de Inspecciones no reintroduce title, visitTitle ni plannedEndAt', () => {

From 100d457484a2cfae1a67999a6b8dd944031d2fa1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 11:42:48 -0300
Subject: [PATCH 209/224] test(f4): guard Android inspection contract from
 legacy fields

---
 .../unit/f4-inspection-legacy-fields.test.ts     | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
index 47e9508..90a7b63 100644
--- a/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
+++ b/api-v3/test/unit/f4-inspection-legacy-fields.test.ts
@@ -61,6 +61,22 @@ test('F4: el contrato WEB de Inspecciones no reintroduce title, visitTitle ni pl
   assert.doesNotMatch(inspectionContract, /\bplannedEndAt\b/);
 });
 
+test('F4: el contrato Android de Inspecciones no reintroduce title ni plannedEndAt', () => {
+  const android = read('../android-app/app/src/main/java/com/korexlabs/dhinspeccion/data/DhMobile.kt');
+  const summaryStart = android.indexOf('data class VisitSummary(');
+  const summaryEnd = android.indexOf('data class VisitMeta(');
+  const detailStart = android.indexOf('data class VisitDetail(');
+  const detailEnd = android.indexOf('// ---------- Field inventory ----------');
+  assert.notEqual(summaryStart, -1);
+  assert.notEqual(summaryEnd, -1);
+  assert.notEqual(detailStart, -1);
+  assert.notEqual(detailEnd, -1);
+
+  const visitContracts = `${android.slice(summaryStart, summaryEnd)}\n${android.slice(detailStart, detailEnd)}`;
+  assert.doesNotMatch(visitContracts, /\bval title\s*:/);
+  assert.doesNotMatch(visitContracts, /\bplannedEndAt\b/);
+});
+
 test('F4: la migración respalda datos antes de retirar columnas legacy', async () => {
   const statements: string[] = [];
   const queryRunner = {

From 95a41f39d7054913e61dffcf4db6225a133da811 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 13:44:51 -0300
Subject: [PATCH 210/224] fix(f4): align verification and web contracts with
 legacy cleanup

---
 api-v3/src/database/entities/index.ts             |  1 -
 .../inspection-verifications.service.ts           |  2 --
 scripts/check-f3-1-web-contract.sh                | 15 +++++++++------
 3 files changed, 9 insertions(+), 9 deletions(-)
 mode change 100644 => 100755 scripts/check-f3-1-web-contract.sh

diff --git a/api-v3/src/database/entities/index.ts b/api-v3/src/database/entities/index.ts
index 8aa0bea..bbc688a 100644
--- a/api-v3/src/database/entities/index.ts
+++ b/api-v3/src/database/entities/index.ts
@@ -36,7 +36,6 @@ export { InspectionActAsset } from './inspection-act-asset.entity';
 export {
   InspectionReport,
   InspectionReportPdfStatus,
-  InspectionReportReviewStatus,
   InspectionReportStatus,
   InspectionReportWordStatus,
 } from './inspection-report.entity';
diff --git a/api-v3/src/inspection-verifications/inspection-verifications.service.ts b/api-v3/src/inspection-verifications/inspection-verifications.service.ts
index 5ef3e06..a2fcdcc 100644
--- a/api-v3/src/inspection-verifications/inspection-verifications.service.ts
+++ b/api-v3/src/inspection-verifications/inspection-verifications.service.ts
@@ -564,8 +564,6 @@ export class InspectionVerificationsService {
 
       const visit = manager.getRepository(InspectionVisit).create({
         code,
-        // Compatibilidad temporal de persistencia hasta retirar la columna legacy.
-        title: code,
         objective: 'Verificar en campo la resolución de hallazgos con fecha de control programada.',
         status: InspectionVisitStatus.DRAFT,
         scopeAssetId: areaId,
diff --git a/scripts/check-f3-1-web-contract.sh b/scripts/check-f3-1-web-contract.sh
old mode 100644
new mode 100755
index 83acb70..f9567f8
--- a/scripts/check-f3-1-web-contract.sh
+++ b/scripts/check-f3-1-web-contract.sh
@@ -8,18 +8,21 @@ PAGE="$ROOT/web-v2/src/pages/InventoryCreatePage.tsx"
 
 for file in "$LAYOUT" "$APP" "$PAGE"; do
   test -f "$file" || {
-    echo "F3.1 WEB contract: falta $file"
+    echo "F4 WEB contract: falta $file"
     exit 1
   }
 done
 
 if grep -Fq "label: 'Relevamientos'" "$LAYOUT"; then
-  echo "F3.1 WEB contract: Relevamientos no debe volver al menú principal"
+  echo "F4 WEB contract: Relevamientos no debe volver al menú principal"
+  exit 1
+fi
+
+if grep -Fq 'path="/relevamiento/*"' "$APP"; then
+  echo "F4 WEB contract: Survey/Relevamiento no debe volver a exponer rutas activas"
   exit 1
 fi
 
-grep -Fq 'path="/relevamiento/*"' "$APP"
-grep -Fq 'Navigate to="/inventarios" replace' "$APP"
 grep -Fq 'path="/inventarios/nuevo"' "$APP"
 grep -Fq 'InventoryCreatePage' "$APP"
 
@@ -28,10 +31,10 @@ for kind in AREA YACIMIENTO INSTALACION SUBINSTALACION; do
 done
 
 if grep -Fq "kind: 'EQUIPO'" "$PAGE"; then
-  echo "F3.1 WEB contract: el alta guiada no debe restaurar EQUIPO como quinto nivel estructural"
+  echo "F4 WEB contract: el alta guiada no debe restaurar EQUIPO como quinto nivel estructural"
   exit 1
 fi
 
 grep -Fq 'getInventoryFamilyFindings' "$PAGE"
 
-echo 'F3.1 WEB contract: OK'
+echo 'F4 WEB contract: OK'

From 30353c338b608a9f07f7513f97f12948201917e9 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 13:52:24 -0300
Subject: [PATCH 211/224] fix(f4): expose recurrence state and close ci type
 gaps

---
 .../inventory-function.service.ts             |  4 +-
 .../finding-recurrence.controller.ts          |  6 +++
 .../finding-recurrence.service.ts             | 37 ++++++++++++++++++-
 .../inspection-findings.controller.ts         | 10 ++++-
 web-v2/src/components/Icon.tsx                |  3 +-
 web-v2/src/lib/api-f4-augmentation.d.ts       | 11 ++++++
 6 files changed, 64 insertions(+), 7 deletions(-)
 create mode 100644 web-v2/src/lib/api-f4-augmentation.d.ts

diff --git a/api-v3/src/asset-master/inventory-function.service.ts b/api-v3/src/asset-master/inventory-function.service.ts
index 1a2e315..f0a1e39 100644
--- a/api-v3/src/asset-master/inventory-function.service.ts
+++ b/api-v3/src/asset-master/inventory-function.service.ts
@@ -16,12 +16,12 @@ import type {
 } from './dto/inventory-function.dto';
 import { AssetHistoryService } from './asset-history.service';
 
-interface InventoryFunctionRow {
+export interface InventoryFunctionRow {
   id: string; code: string; name: string; description: string | null;
   isActive: boolean; sortOrder: number; createdAt: Date; updatedAt: Date;
 }
 
-interface FunctionAssignmentRow {
+export interface FunctionAssignmentRow {
   id: string; assetId: string; functionId: string; functionCode: string; functionName: string;
   validFrom: Date; validUntil: Date | null; reason: string | null;
   changedBy: string | null; changedByUsername: string | null; createdAt: Date;
diff --git a/api-v3/src/inspection-findings/finding-recurrence.controller.ts b/api-v3/src/inspection-findings/finding-recurrence.controller.ts
index c06e773..369ce91 100644
--- a/api-v3/src/inspection-findings/finding-recurrence.controller.ts
+++ b/api-v3/src/inspection-findings/finding-recurrence.controller.ts
@@ -18,6 +18,12 @@ import { FindingRecurrenceService } from './finding-recurrence.service';
 export class FindingRecurrenceController {
   constructor(private readonly recurrence: FindingRecurrenceService) {}
 
+  @Get(':id/recurrence')
+  @RequirePermissions('inspection_findings.read')
+  state(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
+    return this.recurrence.state(id);
+  }
+
   @Get(':id/recurrence-candidates')
   @RequirePermissions('inspection_findings.read')
   candidates(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
diff --git a/api-v3/src/inspection-findings/finding-recurrence.service.ts b/api-v3/src/inspection-findings/finding-recurrence.service.ts
index c20f384..a06e304 100644
--- a/api-v3/src/inspection-findings/finding-recurrence.service.ts
+++ b/api-v3/src/inspection-findings/finding-recurrence.service.ts
@@ -26,6 +26,12 @@ interface FindingRecurrenceContext {
   visitStatus: string;
 }
 
+export interface FindingRecurrenceState {
+  isRecurrence: boolean;
+  recurrenceOfFindingId: string | null;
+  recurrenceOfFindingCode: string | null;
+}
+
 function comparable(value: string): string {
   return value
     .normalize('NFD')
@@ -44,6 +50,25 @@ export class FindingRecurrenceService {
     private readonly findings: InspectionFindingsService,
   ) {}
 
+  async state(id: string): Promise<FindingRecurrenceState> {
+    const [row] = await this.dataSource.query(`
+      SELECT
+        finding.is_recurrence AS "isRecurrence",
+        finding.recurrence_of_finding_id AS "recurrenceOfFindingId",
+        antecedent.code AS "recurrenceOfFindingCode"
+      FROM inspection_findings finding
+      LEFT JOIN inspection_findings antecedent ON antecedent.id = finding.recurrence_of_finding_id
+      WHERE finding.id = $1
+    `, [id]) as FindingRecurrenceState[];
+    if (!row) {
+      throw new NotFoundException({
+        code: 'INSPECTION_FINDING_NOT_FOUND',
+        message: 'Hallazgo no encontrado',
+      });
+    }
+    return row;
+  }
+
   async candidates(id: string) {
     const current = await this.requireFinding(this.dataSource.manager, id, false);
     const rows = await this.dataSource.query(`
@@ -138,7 +163,11 @@ export class FindingRecurrenceService {
         metadata: { actId: current.actId, visitId: current.visitId, recurrenceAction: 'LINKED' },
       }, manager);
     });
-    return this.findings.getById(id);
+    const [finding, recurrence] = await Promise.all([
+      this.findings.getById(id),
+      this.state(id),
+    ]);
+    return { ...finding, ...recurrence };
   }
 
   async clear(
@@ -171,7 +200,11 @@ export class FindingRecurrenceService {
         metadata: { actId: current.actId, visitId: current.visitId, recurrenceAction: 'CLEARED' },
       }, manager);
     });
-    return this.findings.getById(id);
+    const [finding, recurrence] = await Promise.all([
+      this.findings.getById(id),
+      this.state(id),
+    ]);
+    return { ...finding, ...recurrence };
   }
 
   private async requireFinding(
diff --git a/api-v3/src/inspection-findings/inspection-findings.controller.ts b/api-v3/src/inspection-findings/inspection-findings.controller.ts
index 6e1d522..20ad646 100644
--- a/api-v3/src/inspection-findings/inspection-findings.controller.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.controller.ts
@@ -16,6 +16,7 @@ import { CloseInspectionFindingDto } from './dto/close-inspection-finding.dto';
 import { CreateInspectionFindingDto } from './dto/create-inspection-finding.dto';
 import { ListInspectionFindingsQueryDto } from './dto/list-inspection-findings-query.dto';
 import { UpdateInspectionFindingDto } from './dto/update-inspection-finding.dto';
+import { FindingRecurrenceService } from './finding-recurrence.service';
 import { InspectionFindingWorklistService } from './inspection-finding-worklist.service';
 import { InspectionFindingsService } from './inspection-findings.service';
 
@@ -46,6 +47,7 @@ export class InspectionFindingsController {
   constructor(
     private readonly findings: InspectionFindingsService,
     private readonly worklist: InspectionFindingWorklistService,
+    private readonly recurrence: FindingRecurrenceService,
   ) {}
 
   @Get()
@@ -56,8 +58,12 @@ export class InspectionFindingsController {
 
   @Get(':id')
   @RequirePermissions('inspection_findings.read')
-  get(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
-    return this.findings.getById(id);
+  async get(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
+    const [finding, recurrence] = await Promise.all([
+      this.findings.getById(id),
+      this.recurrence.state(id),
+    ]);
+    return { ...finding, ...recurrence };
   }
 
   @Get(':id/verification-history')
diff --git a/web-v2/src/components/Icon.tsx b/web-v2/src/components/Icon.tsx
index bcc1fc3..cb66ed2 100644
--- a/web-v2/src/components/Icon.tsx
+++ b/web-v2/src/components/Icon.tsx
@@ -1,7 +1,7 @@
 export type IconName =
   | 'home' | 'map' | 'layers' | 'calendar' | 'clipboard' | 'alert'
   | 'history' | 'users' | 'shield' | 'audit' | 'logout' | 'menu'
-  | 'plus' | 'search' | 'edit' | 'chevron' | 'check' | 'key' | 'upload' | 'mail';
+  | 'plus' | 'search' | 'edit' | 'chevron' | 'check' | 'key' | 'upload' | 'mail' | 'lock';
 
 export function Icon({ name, size = 18 }: { name: IconName; size?: number }) {
   const paths: Record<IconName, React.ReactNode> = {
@@ -25,6 +25,7 @@ export function Icon({ name, size = 18 }: { name: IconName; size?: number }) {
     key: <><circle cx="8" cy="15" r="4"/><path d="m11 12 9-9M15 8l3 3M17 6l2 2"/></>,
     upload: <><path d="M12 16V4"/><path d="m7 9 5-5 5 5"/><path d="M5 20h14"/></>,
     mail: <><rect x="3" y="5" width="18" height="14" rx="2"/><path d="m3 7 9 6 9-6"/></>,
+    lock: <><rect x="5" y="10" width="14" height="10" rx="2"/><path d="M8 10V7a4 4 0 0 1 8 0v3"/></>,
   };
   return (
     <svg className="icon" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
diff --git a/web-v2/src/lib/api-f4-augmentation.d.ts b/web-v2/src/lib/api-f4-augmentation.d.ts
new file mode 100644
index 0000000..1eaf583
--- /dev/null
+++ b/web-v2/src/lib/api-f4-augmentation.d.ts
@@ -0,0 +1,11 @@
+import './api';
+
+declare module './api' {
+  interface InspectionFinding {
+    isRecurrence: boolean;
+    recurrenceOfFindingId: string | null;
+    recurrenceOfFindingCode: string | null;
+  }
+}
+
+export {};

From 7b6460dff2156f40f9d172fdc2490c37df9c4a61 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 13:55:11 -0300
Subject: [PATCH 212/224] fix(f4): name recurrence response contracts for api
 declarations

---
 .../src/inspection-findings/finding-recurrence.service.ts  | 7 +++++--
 .../inspection-findings/inspection-findings.controller.ts  | 6 +++++-
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/api-v3/src/inspection-findings/finding-recurrence.service.ts b/api-v3/src/inspection-findings/finding-recurrence.service.ts
index a06e304..ffa4cc9 100644
--- a/api-v3/src/inspection-findings/finding-recurrence.service.ts
+++ b/api-v3/src/inspection-findings/finding-recurrence.service.ts
@@ -13,6 +13,7 @@ import { AuditAction } from '../database/entities';
 import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
 import type { SetFindingRecurrenceDto } from './dto/set-finding-recurrence.dto';
 import { InspectionFindingsService } from './inspection-findings.service';
+import type { InspectionFindingView } from './inspection-findings.service';
 
 interface FindingRecurrenceContext {
   id: string;
@@ -32,6 +33,8 @@ export interface FindingRecurrenceState {
   recurrenceOfFindingCode: string | null;
 }
 
+export type FindingWithRecurrenceView = InspectionFindingView & FindingRecurrenceState;
+
 function comparable(value: string): string {
   return value
     .normalize('NFD')
@@ -104,7 +107,7 @@ export class FindingRecurrenceService {
     dto: SetFindingRecurrenceDto,
     principal: AuthPrincipal,
     request: RequestWithContext,
-  ) {
+  ): Promise<FindingWithRecurrenceView> {
     assertMobileInspector(principal);
     await this.dataSource.transaction(async (manager) => {
       const current = await this.requireFinding(manager, id, true);
@@ -174,7 +177,7 @@ export class FindingRecurrenceService {
     id: string,
     principal: AuthPrincipal,
     request: RequestWithContext,
-  ) {
+  ): Promise<FindingWithRecurrenceView> {
     assertMobileInspector(principal);
     await this.dataSource.transaction(async (manager) => {
       const current = await this.requireFinding(manager, id, true);
diff --git a/api-v3/src/inspection-findings/inspection-findings.controller.ts b/api-v3/src/inspection-findings/inspection-findings.controller.ts
index 20ad646..f55e41b 100644
--- a/api-v3/src/inspection-findings/inspection-findings.controller.ts
+++ b/api-v3/src/inspection-findings/inspection-findings.controller.ts
@@ -17,8 +17,10 @@ import { CreateInspectionFindingDto } from './dto/create-inspection-finding.dto'
 import { ListInspectionFindingsQueryDto } from './dto/list-inspection-findings-query.dto';
 import { UpdateInspectionFindingDto } from './dto/update-inspection-finding.dto';
 import { FindingRecurrenceService } from './finding-recurrence.service';
+import type { FindingRecurrenceState } from './finding-recurrence.service';
 import { InspectionFindingWorklistService } from './inspection-finding-worklist.service';
 import { InspectionFindingsService } from './inspection-findings.service';
+import type { InspectionFindingView } from './inspection-findings.service';
 
 @Controller('inspection-acts/:actId/findings')
 export class InspectionActFindingsController {
@@ -58,7 +60,9 @@ export class InspectionFindingsController {
 
   @Get(':id')
   @RequirePermissions('inspection_findings.read')
-  async get(@Param('id', new ParseUUIDPipe({ version: '4' })) id: string) {
+  async get(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+  ): Promise<InspectionFindingView & FindingRecurrenceState> {
     const [finding, recurrence] = await Promise.all([
       this.findings.getById(id),
       this.recurrence.state(id),

From 4df8f40dd449c31896de12ece91f47475bb08fce Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 14:39:55 -0300
Subject: [PATCH 213/224] test(f4): align legacy contracts with lifecycle model

---
 api-v3/test/unit/dashboard-service.test.ts    | 21 ++++-----
 .../test/unit/f3-2-mobile-multi-acta.test.ts  |  7 +--
 api-v3/test/unit/inspection-acts-dto.test.ts  |  6 ++-
 .../inspection-closing-authorization.test.ts  |  8 ++--
 .../inspection-findings-authorization.test.ts | 46 +++++--------------
 ...nspection-findings-office-workflow.test.ts |  4 +-
 .../inspection-visits-authorization.test.ts   |  6 ++-
 .../unit/mobile-inspector-integration.test.ts | 12 ++---
 .../phase-d5-3-15-document-center.test.ts     |  3 +-
 ...hase-d5-3-16-verification-planning.test.ts |  7 +--
 ...hase-d5-3-20-automatic-word-report.test.ts |  2 +-
 ...se-d5-4-contextual-finding-catalog.test.ts |  1 -
 .../phase-d5-5-web-planning-checklist.test.ts | 18 ++++----
 ...e-d5-6-4-quick-inspection-planning.test.ts | 19 +++++---
 14 files changed, 73 insertions(+), 87 deletions(-)

diff --git a/api-v3/test/unit/dashboard-service.test.ts b/api-v3/test/unit/dashboard-service.test.ts
index 3281fef..f030d9b 100644
--- a/api-v3/test/unit/dashboard-service.test.ts
+++ b/api-v3/test/unit/dashboard-service.test.ts
@@ -2,7 +2,7 @@ import { strict as assert } from 'node:assert';
 import test from 'node:test';
 import { DashboardService } from '../../src/dashboard/dashboard.service';
 
-test('DashboardService returns numeric counts and recent activity consistently', async () => {
+test('DashboardService returns F4 operational counts and recent activity consistently', async () => {
   const recent = [{
     id: 'event-id',
     occurredAt: new Date('2026-08-13T12:00:00.000Z'),
@@ -17,9 +17,8 @@ test('DashboardService returns numeric counts and recent activity consistently',
         return [{
           activeUsers: '4', inactiveUsers: '2', activeSessions: '3',
           totalAssets: '12', assetsNeedValidation: '4', assetsWithoutGeometry: '6', plannedInspections: '2',
-          openFindings: '8', awaitingCompanyResponse: '5', overdueCompanyResponses: '2',
-          companyResponsesDueNext7Days: '1', awaitingVerificationSchedule: '4',
-          overdueControls: '2', controlsNext30Days: '3',
+          openFindings: '8', findingsWithoutControlDate: '5', overdueControls: '2', controlsNext30Days: '3',
+          reportsWorking: '1', reportsOfficialized: '2', sealedActsWithoutReport: '4',
         }];
       }
       if (sql.includes('FROM inspection_findings finding')) return [];
@@ -32,20 +31,20 @@ test('DashboardService returns numeric counts and recent activity consistently',
 
   const result = await new DashboardService(dataSource as never).summary();
   assert.deepEqual(result.counts, {
-    activeUsers: 4,
-    inactiveUsers: 2,
-    activeSessions: 3,
     totalAssets: 12,
     assetsNeedValidation: 4,
     assetsWithoutGeometry: 6,
     plannedInspections: 2,
+    activeUsers: 4,
+    inactiveUsers: 2,
+    activeSessions: 3,
     openFindings: 8,
-    awaitingCompanyResponse: 5,
-    overdueCompanyResponses: 2,
-    companyResponsesDueNext7Days: 1,
-    awaitingVerificationSchedule: 4,
+    findingsWithoutControlDate: 5,
     overdueControls: 2,
     controlsNext30Days: 3,
+    reportsWorking: 1,
+    reportsOfficialized: 2,
+    sealedActsWithoutReport: 4,
   });
   assert.equal(result.recentAudit, recent);
   assert.deepEqual(result.upcomingControls, []);
diff --git a/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts b/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts
index 084934b..5369484 100644
--- a/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts
+++ b/api-v3/test/unit/f3-2-mobile-multi-acta.test.ts
@@ -11,14 +11,15 @@ test('F3.2/F4 mantiene múltiples Actas con un solo borrador simultáneo por ins
   assert.match(migration, /WHERE status = 'DRAFT'/);
 });
 
-test('F3.2 permite seleccionar el Acta explícitamente al trabajar Hallazgos desde la APK', () => {
+test('F3.2/F4 exige seleccionar el Acta explícitamente al crear Hallazgos desde la APK', () => {
   const controller = read('src/inspection-visits/field-findings.controller.ts');
   const service = read('src/inspection-visits/field-findings.service.ts');
   const dto = read('src/inspection-visits/dto/create-field-finding.dto.ts');
   assert.match(controller, /FieldFindingActQueryDto/);
   assert.match(controller, /query\.actId/);
-  assert.match(dto, /actId\?: string/);
-  assert.match(service, /actSelectionMode: actId \? 'EXPLICIT' : 'LEGACY_SINGLE_DRAFT'/);
+  assert.match(dto, /actId!: string/);
+  assert.match(dto, /El Acta es obligatoria/);
+  assert.match(service, /this\.requireDraftAct\(visitId, dto\.actId\)/);
   assert.match(service, /WHERE id=\$1::uuid AND visit_id=\$2::uuid/);
   assert.match(service, /FIELD_FINDING_ACT_NOT_DRAFT/);
   assert.match(service, /FIELD_FINDING_ASSET_NOT_IN_ACT/);
diff --git a/api-v3/test/unit/inspection-acts-dto.test.ts b/api-v3/test/unit/inspection-acts-dto.test.ts
index 14297c4..dc06787 100644
--- a/api-v3/test/unit/inspection-acts-dto.test.ts
+++ b/api-v3/test/unit/inspection-acts-dto.test.ts
@@ -5,18 +5,21 @@ import { plainToInstance } from 'class-transformer';
 import { validate } from 'class-validator';
 import { CancelInspectionActDto } from '../../src/inspection-acts/dto/cancel-inspection-act.dto';
 import { CreateInspectionActDto } from '../../src/inspection-acts/dto/create-inspection-act.dto';
+import { InspectionActUrgency } from '../../src/database/entities';
 
 const ASSET_ID = '16e54e65-60cf-4739-b0d1-ccdd904fbfd5';
 
-test('inspection act DTO accepts content and selected visit assets', async () => {
+test('inspection act DTO accepts urgency, content and selected visit assets', async () => {
   const dto = plainToInstance(CreateInspectionActDto, {
     occurredAt: '2026-08-14T15:30:00.000Z',
+    urgency: InspectionActUrgency.NON_URGENT,
     title: ' Verificación de instalación ',
     summary: ' Se inspeccionó el activo seleccionado. ',
     observations: ' Sin novedades. ',
     assetIds: [ASSET_ID],
   });
   assert.deepEqual(await validate(dto), []);
+  assert.equal(dto.urgency, InspectionActUrgency.NON_URGENT);
   assert.equal(dto.title, 'Verificación de instalación');
   assert.equal(dto.summary, 'Se inspeccionó el activo seleccionado.');
   assert.equal(dto.observations, 'Sin novedades.');
@@ -25,6 +28,7 @@ test('inspection act DTO accepts content and selected visit assets', async () =>
 test('inspection act DTO rejects duplicate assets', async () => {
   const dto = plainToInstance(CreateInspectionActDto, {
     occurredAt: '2026-08-14T15:30:00.000Z',
+    urgency: InspectionActUrgency.NON_URGENT,
     title: 'Acta',
     summary: 'Contenido',
     assetIds: [ASSET_ID, ASSET_ID],
diff --git a/api-v3/test/unit/inspection-closing-authorization.test.ts b/api-v3/test/unit/inspection-closing-authorization.test.ts
index 66b8037..3fb20a5 100644
--- a/api-v3/test/unit/inspection-closing-authorization.test.ts
+++ b/api-v3/test/unit/inspection-closing-authorization.test.ts
@@ -12,14 +12,14 @@ function permissionFor(controller: object, method: string): string[] {
   return Reflect.getMetadata(REQUIRED_PERMISSIONS_KEY, handler) as string[];
 }
 
-test('D5 closing endpoints separate read, prepare, sign and close permissions', () => {
+test('F4 closing endpoints separate read, lock, sign and seal permissions without reopen', () => {
   assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'get'), ['inspection_closure.read']);
   assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'responsible'), ['inspection_closure.prepare']);
-  assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'ready'), ['inspection_closure.prepare']);
-  assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'reopen'), ['inspection_closure.prepare']);
+  assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'lock'), ['inspection_closure.prepare']);
+  assert.equal('reopen' in InspectionClosingController.prototype, false);
   assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'inspectorSignature'), ['inspection_closure.sign']);
   assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'companySignature'), ['inspection_closure.sign']);
   assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'companyOutcome'), ['inspection_closure.sign']);
-  assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'close'), ['inspection_closure.close']);
+  assert.deepEqual(permissionFor(InspectionClosingController.prototype, 'seal'), ['inspection_closure.close']);
   assert.deepEqual(permissionFor(InspectionSignatureContentController.prototype, 'content'), ['inspection_closure.read']);
 });
diff --git a/api-v3/test/unit/inspection-findings-authorization.test.ts b/api-v3/test/unit/inspection-findings-authorization.test.ts
index b4b4257..25e2737 100644
--- a/api-v3/test/unit/inspection-findings-authorization.test.ts
+++ b/api-v3/test/unit/inspection-findings-authorization.test.ts
@@ -13,40 +13,16 @@ function permissionFor(controller: object, method: string): string[] {
   return Reflect.getMetadata(REQUIRED_PERMISSIONS_KEY, handler) as string[];
 }
 
-test('finding endpoints separate catalog, content, follow-up and closure permissions', () => {
-  assert.deepEqual(permissionFor(FindingCatalogController.prototype, 'list'), [
-    'finding_catalog.read',
-  ]);
-  for (const method of [
-    'adminList',
-    'createCategory',
-    'updateCategory',
-    'createItem',
-    'updateItem',
-  ]) {
-    assert.deepEqual(permissionFor(FindingCatalogController.prototype, method), [
-      'finding_catalog.manage',
-    ]);
+test('F4 finding endpoints separate catalog, content and closure while mutable follow-up is retired', () => {
+  assert.deepEqual(permissionFor(FindingCatalogController.prototype, 'list'), ['finding_catalog.read']);
+  for (const method of ['adminList', 'createCategory', 'updateCategory', 'createItem', 'updateItem']) {
+    assert.deepEqual(permissionFor(FindingCatalogController.prototype, method), ['finding_catalog.manage']);
   }
-  assert.deepEqual(permissionFor(InspectionActFindingsController.prototype, 'list'), [
-    'inspection_findings.read',
-  ]);
-  assert.deepEqual(permissionFor(InspectionActFindingsController.prototype, 'create'), [
-    'inspection_findings.create',
-  ]);
-  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'list'), [
-    'inspection_findings.read',
-  ]);
-  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'get'), [
-    'inspection_findings.read',
-  ]);
-  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'update'), [
-    'inspection_findings.update',
-  ]);
-  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'updateFollowUp'), [
-    'inspection_findings.follow_up',
-  ]);
-  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'close'), [
-    'inspection_findings.close',
-  ]);
+  assert.deepEqual(permissionFor(InspectionActFindingsController.prototype, 'list'), ['inspection_findings.read']);
+  assert.deepEqual(permissionFor(InspectionActFindingsController.prototype, 'create'), ['inspection_findings.create']);
+  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'list'), ['inspection_findings.read']);
+  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'get'), ['inspection_findings.read']);
+  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'update'), ['inspection_findings.update']);
+  assert.equal('updateFollowUp' in InspectionFindingsController.prototype, false);
+  assert.deepEqual(permissionFor(InspectionFindingsController.prototype, 'close'), ['inspection_findings.close']);
 });
diff --git a/api-v3/test/unit/inspection-findings-office-workflow.test.ts b/api-v3/test/unit/inspection-findings-office-workflow.test.ts
index b07b812..b14d607 100644
--- a/api-v3/test/unit/inspection-findings-office-workflow.test.ts
+++ b/api-v3/test/unit/inspection-findings-office-workflow.test.ts
@@ -13,9 +13,9 @@ test('D5.3.13 separates company response due dates from verification due dates',
   assert.match(source, /verificationOverdue/);
 });
 
-test('D5.3.13 exposes a global office queue and controlled finding closure', () => {
+test('D5.3.13/F4 exposes the global worklist and controlled finding closure', () => {
   assert.match(controller, /@Get\(\)/);
-  assert.match(controller, /this\.findings\.listGlobal\(query\)/);
+  assert.match(controller, /this\.worklist\.list\(query\)/);
   assert.match(controller, /@Patch\(':id\/close'\)/);
   assert.match(source, /finding\.status = InspectionFindingStatus\.CLOSED/);
   assert.match(source, /finding\.closureNotes = dto\.closureNotes/);
diff --git a/api-v3/test/unit/inspection-visits-authorization.test.ts b/api-v3/test/unit/inspection-visits-authorization.test.ts
index 450d2a7..b8b1c4c 100644
--- a/api-v3/test/unit/inspection-visits-authorization.test.ts
+++ b/api-v3/test/unit/inspection-visits-authorization.test.ts
@@ -10,7 +10,7 @@ function permissionFor(method: string): string[] {
   return Reflect.getMetadata(REQUIRED_PERMISSIONS_KEY, handler) as string[];
 }
 
-test('inspection visit endpoints separate reading, planning, assignment and execution', () => {
+test('F4 inspection endpoints separate reading, planning, assignment and execution', () => {
   assert.deepEqual(permissionFor('list'), ['inspections.read']);
   assert.deepEqual(permissionFor('get'), ['inspections.read']);
   assert.deepEqual(permissionFor('assignees'), ['inspections.assign']);
@@ -18,7 +18,9 @@ test('inspection visit endpoints separate reading, planning, assignment and exec
   assert.deepEqual(permissionFor('update'), ['inspections.manage']);
   assert.deepEqual(permissionFor('replaceAssets'), ['inspections.manage']);
   assert.deepEqual(permissionFor('replaceTeam'), ['inspections.assign']);
-  assert.deepEqual(permissionFor('changeStatus'), ['inspections.manage']);
+  assert.deepEqual(permissionFor('plan'), ['inspections.manage']);
+  assert.deepEqual(permissionFor('unplan'), ['inspections.manage']);
   assert.deepEqual(permissionFor('start'), ['inspections.execute']);
   assert.deepEqual(permissionFor('close'), ['inspections.execute']);
+  assert.deepEqual(permissionFor('cancel'), ['inspections.manage']);
 });
diff --git a/api-v3/test/unit/mobile-inspector-integration.test.ts b/api-v3/test/unit/mobile-inspector-integration.test.ts
index 40917e1..7a970bc 100644
--- a/api-v3/test/unit/mobile-inspector-integration.test.ts
+++ b/api-v3/test/unit/mobile-inspector-integration.test.ts
@@ -11,15 +11,15 @@ function policyCalls(value: string): number {
   return value.match(/assertMobileInspector\(principal\);/g)?.length ?? 0;
 }
 
-test('D5.1 applies the mobile-inspector policy to every field operation', async () => {
-  const [visits, acts, findings, evidence, closing] = await Promise.all([
-    source('inspection-visits/inspection-visits.service.ts'),
+test('D5.1/F4 applies the mobile-inspector policy to every field operation', async () => {
+  const [lifecycle, acts, findings, evidence, closing] = await Promise.all([
+    source('inspection-visits/inspection-visit-lifecycle.service.ts'),
     source('inspection-acts/inspection-acts.service.ts'),
     source('inspection-findings/inspection-findings.service.ts'),
     source('inspection-findings/inspection-evidence.service.ts'),
     source('inspection-closing/inspection-closing.service.ts'),
   ]);
-  assert.equal(policyCalls(visits), 2);
+  assert.equal(policyCalls(lifecycle), 2);
   assert.equal(policyCalls(acts), 3);
   assert.equal(policyCalls(findings), 2);
   assert.equal(policyCalls(evidence), 1);
@@ -34,9 +34,7 @@ test('D5.1 leaves company follow-up outside the field-operation gate', async ()
 });
 
 test('D5.1 migration grants operational permissions only to inspector', async () => {
-  const migration = await source(
-    'database/migrations/1787331600000-phase-d5-1-mobile-inspection-policy.ts',
-  );
+  const migration = await source('database/migrations/1787331600000-phase-d5-1-mobile-inspection-policy.ts');
   assert.match(migration, /role\.code <> 'inspector'/);
   assert.match(migration, /role\.code = 'inspector'/);
   assert.doesNotMatch(migration, /inspection_findings\.follow_up/);
diff --git a/api-v3/test/unit/phase-d5-3-15-document-center.test.ts b/api-v3/test/unit/phase-d5-3-15-document-center.test.ts
index 948a4ac..4b327ce 100644
--- a/api-v3/test/unit/phase-d5-3-15-document-center.test.ts
+++ b/api-v3/test/unit/phase-d5-3-15-document-center.test.ts
@@ -19,7 +19,8 @@ test('D5.3.15/F4 exposes global acts and report emission after an Act is SEALED'
 test('D5.3.15/F4 freezes the immutable sealed Act snapshot as the INF source', () => {
   assert.match(reportService, /assertMobileInspector\(principal\)/);
   assert.match(reportService, /final_snapshot AS "finalSnapshot"/);
-  assert.match(reportService, /DocumentSequenceType\.REPORT/);
+  assert.match(reportService, /const reportNumber = act\.actNumber/);
+  assert.match(reportService, /act\.code\.replace\(\/\^ACT-\/, 'INF-'\)/);
   assert.match(reportService, /sha256CanonicalJson\(frozenSnapshot\)/);
   assert.match(reportService, /InspectionReportStatus\.WORKING/);
   assert.match(reportService, /INSPECTION_REPORT_GENERATED/);
diff --git a/api-v3/test/unit/phase-d5-3-16-verification-planning.test.ts b/api-v3/test/unit/phase-d5-3-16-verification-planning.test.ts
index 2e2bcda..c80118c 100644
--- a/api-v3/test/unit/phase-d5-3-16-verification-planning.test.ts
+++ b/api-v3/test/unit/phase-d5-3-16-verification-planning.test.ts
@@ -7,10 +7,11 @@ const service = readFileSync(resolve(process.cwd(), 'src/inspection-verification
 const migration = readFileSync(resolve(process.cwd(), 'src/database/migrations/1788112800000-phase-d5-3-16-verification-planning.ts'), 'utf8');
 const visitService = readFileSync(resolve(process.cwd(), 'src/inspection-visits/inspection-visits.service.ts'), 'utf8');
 
-test('D5.3.16 builds the verification queue from the second finding deadline', () => {
-  assert.match(service, /company_response_received_on IS NOT NULL/);
+test('D5.3.16/F4 builds the verification queue from the next control date and unresolved latest result', () => {
+  assert.doesNotMatch(service, /company_response_received_on IS NOT NULL/);
   assert.match(service, /finding\.next_control_on IS NOT NULL/);
-  assert.match(service, /verification_visit\.id IS NULL/);
+  assert.match(service, /latest_verification\.outcome/);
+  assert.match(service, /<> 'RESOLVED'/);
   assert.match(service, /overdueUnplanned/);
 });
 
diff --git a/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts b/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts
index fd6b2d9..61a5fb1 100644
--- a/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts
+++ b/api-v3/test/unit/phase-d5-3-20-automatic-word-report.test.ts
@@ -24,7 +24,7 @@ test('D5.3.20 stores an integrity-checked Word artifact without changing the fro
   assert.match(migration, /word_sha256 char\(64\)/);
   assert.match(migration, /word_generated_at timestamptz/);
   assert.match(wordService, /createHash\('sha256'\)/);
-  assert.match(wordService, /word_status = 'READY'/);
+  assert.match(wordService, /word_status\s*=\s*'READY'/);
   assert.match(controller, /@Get\(':id\/word'\)/);
 });
 
diff --git a/api-v3/test/unit/phase-d5-4-contextual-finding-catalog.test.ts b/api-v3/test/unit/phase-d5-4-contextual-finding-catalog.test.ts
index 0369f07..2a0c907 100644
--- a/api-v3/test/unit/phase-d5-4-contextual-finding-catalog.test.ts
+++ b/api-v3/test/unit/phase-d5-4-contextual-finding-catalog.test.ts
@@ -40,7 +40,6 @@ test('D5.4 stores suggested and actual severity independently on the 1 to 10 sca
   assert.match(createFindingDto, /severity\?: number/);
   assert.match(findingsService, /suggestedSeverity: catalog\?\.suggestedSeverity/);
   assert.match(findingsService, /severity: dto\.severity \?\? catalog\?\.suggestedSeverity/);
-  assert.match(closingService, /finding\.suggested_severity AS "suggestedSeverity"/);
   assert.match(closingService, /finding\.severity/);
   assert.match(wordBuilder, /'Gravedad'/);
 });
diff --git a/api-v3/test/unit/phase-d5-5-web-planning-checklist.test.ts b/api-v3/test/unit/phase-d5-5-web-planning-checklist.test.ts
index 90d58ea..89b011c 100644
--- a/api-v3/test/unit/phase-d5-5-web-planning-checklist.test.ts
+++ b/api-v3/test/unit/phase-d5-5-web-planning-checklist.test.ts
@@ -45,22 +45,22 @@ test('D5.5 treats manual additions as preventive and requires an auditable reaso
   assert.match(dto, /@MinLength\(10\)/);
 });
 
-test('D5.5 keeps verification visits inside the same Area Operator planning contract and start remains APK-only', () => {
+test('D5.5/F4 keeps verification visits inside the Area Operator contract and start remains APK-only', () => {
   const verification = read('src/inspection-verifications/inspection-verifications.service.ts');
-  const visits = read('src/inspection-visits/inspection-visits.service.ts');
+  const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
   assert.match(verification, /operationalAreaId: areaId/);
   assert.match(verification, /operatorCompanyId: companyId/);
   assert.match(verification, /planning_source = 'VERIFICATION'/);
-  assert.match(visits, /assertMobileInspector\(principal\)/);
-  assert.match(visits, /INSPECTION_CHECKLIST_REQUIRED/);
+  assert.match(lifecycle, /assertMobileInspector\(principal\)/);
+  assert.match(lifecycle, /INSPECTION_CHECKLIST_REQUIRED/);
 });
 
-test('D5.5 confirmation requires a reviewed current checklist and keeps visit start under mobile inspector policy', () => {
-  const visits = read('src/inspection-visits/inspection-visits.service.ts');
+test('D5.5/F4 requires a current checklist before planning or start and keeps start under mobile policy', () => {
+  const lifecycle = read('src/inspection-visits/inspection-visit-lifecycle.service.ts');
   const policy = read('src/inspection-operations/mobile-inspector-policy.ts');
-  assert.match(visits, /INSPECTION_CHECKLIST_REQUIRED/);
-  assert.match(visits, /checklistGeneratedAt/);
-  assert.match(visits, /assertMobileInspector\(principal\)/);
+  assert.match(lifecycle, /INSPECTION_CHECKLIST_REQUIRED/);
+  assert.match(lifecycle, /checklistGeneratedAt/);
+  assert.match(lifecycle, /assertMobileInspector\(principal\)/);
   assert.match(policy, /transport !== 'bearer'/);
   assert.match(policy, /includes\('inspector'\)/);
 });
diff --git a/api-v3/test/unit/phase-d5-6-4-quick-inspection-planning.test.ts b/api-v3/test/unit/phase-d5-6-4-quick-inspection-planning.test.ts
index c7f2698..52d9f6b 100644
--- a/api-v3/test/unit/phase-d5-6-4-quick-inspection-planning.test.ts
+++ b/api-v3/test/unit/phase-d5-6-4-quick-inspection-planning.test.ts
@@ -6,14 +6,18 @@ import test from 'node:test';
 const root = process.cwd();
 const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
 
-test('D5.6.4 generates inspection codes server-side with an annual transactional sequence', () => {
+test('D5.6.4/F4 generates inspection codes server-side with an annual transactional sequence', () => {
   const generator = read('src/inspection-visits/inspection-visit-code.ts');
-  assert.match(generator, /INS-\$\{year\}-\$\{String\(sequence\)\.padStart\(6, '0'\)\}/);
   assert.match(generator, /pg_advisory_xact_lock/);
   assert.match(generator, /America\/Argentina\/Mendoza/);
+  assert.match(generator, /padStart\(5, '0'\)/);
+  assert.match(generator, /return `INSP-/);
+  assert.match(generator, /dateRow\.day/);
+  assert.match(generator, /dateRow\.month/);
+  assert.match(generator, /dateRow\.short_year/);
 });
 
-test('D5.6.4 creates one inspection from Area Operator start and lead inspector without manual title or end date', () => {
+test('D5.6.4/F4 creates one inspection from Area Operator, start and lead inspector without legacy title or end date', () => {
   const dto = read('src/inspection-visits/dto/create-inspection-visit.dto.ts');
   const service = read('src/inspection-visits/inspection-visits.service.ts');
   assert.doesNotMatch(dto, /code!/);
@@ -23,8 +27,9 @@ test('D5.6.4 creates one inspection from Area Operator start and lead inspector
   assert.match(dto, /operatorCompanyId!/);
   assert.match(dto, /plannedStartAt!/);
   assert.match(dto, /leadInspectorUserId!/);
-  assert.match(service, /title: code/);
-  assert.match(service, /plannedEndAt: null/);
+  assert.match(service, /const code = await nextInspectionVisitCode\(manager, plannedStartAt\)/);
+  assert.doesNotMatch(service, /title: code/);
+  assert.doesNotMatch(service, /plannedEndAt/);
 });
 
 test('D5.6.4 assigns the lead inspector and generates the checklist in the same creation transaction', () => {
@@ -34,10 +39,10 @@ test('D5.6.4 assigns the lead inspector and generates the checklist in the same
   assert.match(service, /await this\.generateChecklistInternal\(manager, visit, principal\.userId\)/);
 });
 
-test('D5.6.4 uses the same inspection numbering and start-only planning for verification visits', () => {
+test('D5.6.4/F4 uses the same inspection numbering and start-only planning for verification visits', () => {
   const dto = read('src/inspection-verifications/dto/plan-verification-visit.dto.ts');
   const service = read('src/inspection-verifications/inspection-verifications.service.ts');
   assert.doesNotMatch(dto, /plannedEndAt/);
   assert.match(service, /nextInspectionVisitCode\(manager, plannedStartAt\)/);
-  assert.match(service, /plannedEndAt: null/);
+  assert.doesNotMatch(service, /plannedEndAt/);
 });

From 3bfa3bce1bb24b31debf1d16f2c6e395e5f8291b Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 14:43:02 -0300
Subject: [PATCH 214/224] fix(f4): require current checklist before inspection
 execution

---
 .../inspection-visits/inspection-visit-lifecycle.service.ts | 6 ++++++
 api-v3/test/unit/mobile-inspector-integration.test.ts       | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
index cb1c4c5..d1d7418 100644
--- a/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
+++ b/api-v3/src/inspection-visits/inspection-visit-lifecycle.service.ts
@@ -302,6 +302,12 @@ export class InspectionVisitLifecycleService {
         message: 'Definí Área/Yacimiento, Operadora, Inspector responsable y fecha de inicio antes de planificar',
       });
     }
+    if (!visit.checklistGeneratedAt || visit.checklistGeneration < 1) {
+      throw new BadRequestException({
+        code: 'INSPECTION_CHECKLIST_REQUIRED',
+        message: 'Generá el checklist automático antes de confirmar la planificación',
+      });
+    }
     const [relation] = await manager.query(`
       SELECT 1
       FROM area_company_relations
diff --git a/api-v3/test/unit/mobile-inspector-integration.test.ts b/api-v3/test/unit/mobile-inspector-integration.test.ts
index 7a970bc..b08e035 100644
--- a/api-v3/test/unit/mobile-inspector-integration.test.ts
+++ b/api-v3/test/unit/mobile-inspector-integration.test.ts
@@ -23,7 +23,7 @@ test('D5.1/F4 applies the mobile-inspector policy to every field operation', asy
   assert.equal(policyCalls(acts), 3);
   assert.equal(policyCalls(findings), 2);
   assert.equal(policyCalls(evidence), 1);
-  assert.equal(policyCalls(closing), 7);
+  assert.equal(policyCalls(closing), 6);
   assert.match(evidence, /purpose === InspectionEvidencePurpose\.OBSERVATION/);
 });
 

From 94a8d5c92f1c802dcbb21b69208cb086029d961c Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 14:51:19 -0300
Subject: [PATCH 215/224] ci: mount web and android contracts read-only in
 preflight

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e3f10d2..4a9081c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -72,6 +72,8 @@ jobs:
           docker run --rm \
             -v "$PWD/api-v3/test:/app/test:ro" \
             -v "$PWD/api-v3/tsconfig.test.json:/app/tsconfig.test.json:ro" \
+            -v "$PWD/web-v2:/web-v2:ro" \
+            -v "$PWD/android-app:/android-app:ro" \
             "$image" npm test
           docker image rm "$image" >/dev/null 2>&1 || true
       - name: Build production images

From e1e44e6352b936361295fb2d73a515ea22717d6a Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 15:06:07 -0300
Subject: [PATCH 216/224] chore: stage one-shot F4 pre-merge corrections

---
 .../workflows/f4-one-shot-premerge-fix.yml    | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 .github/workflows/f4-one-shot-premerge-fix.yml

diff --git a/.github/workflows/f4-one-shot-premerge-fix.yml b/.github/workflows/f4-one-shot-premerge-fix.yml
new file mode 100644
index 0000000..884f59f
--- /dev/null
+++ b/.github/workflows/f4-one-shot-premerge-fix.yml
@@ -0,0 +1,107 @@
+name: F4 one-shot pre-merge corrections
+
+on:
+  push:
+    branches:
+      - feature/f4-backend-saneamiento-documental
+
+permissions:
+  contents: write
+
+jobs:
+  patch:
+    if: github.actor != 'github-actions[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: feature/f4-backend-saneamiento-documental
+
+      - name: Apply audited F4 corrections
+        run: |
+          python - <<'PY'
+          from pathlib import Path
+
+          def replace_once(path: str, old: str, new: str) -> None:
+              file = Path(path)
+              text = file.read_text()
+              count = text.count(old)
+              if count != 1:
+                  raise SystemExit(f"{path}: expected exactly one match, got {count}")
+              file.write_text(text.replace(old, new))
+
+          # 1) Physical DB default must match the active F4 report lifecycle.
+          migration = 'api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts'
+          replace_once(
+              migration,
+              """    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ADD CONSTRAINT chk_inspection_reports_status CHECK (\n        status IN ('WORKING','OFFICIALIZED','FROZEN','CANCELLED')\n      )\n    `);\n\n    await queryRunner.query(`\n      ALTER TABLE inspection_acts\n""",
+              """    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ADD CONSTRAINT chk_inspection_reports_status CHECK (\n        status IN ('WORKING','OFFICIALIZED','FROZEN','CANCELLED')\n      )\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ALTER COLUMN status SET DEFAULT 'WORKING'\n    `);\n\n    await queryRunner.query(`\n      ALTER TABLE inspection_acts\n""",
+          )
+          replace_once(
+              migration,
+              """    await queryRunner.query(`\n      UPDATE inspection_reports\n      SET status='FROZEN'\n      WHERE status IN ('WORKING','OFFICIALIZED')\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      DROP CONSTRAINT IF EXISTS chk_inspection_reports_status\n""",
+              """    await queryRunner.query(`\n      UPDATE inspection_reports\n      SET status='FROZEN'\n      WHERE status IN ('WORKING','OFFICIALIZED')\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ALTER COLUMN status SET DEFAULT 'FROZEN'\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      DROP CONSTRAINT IF EXISTS chk_inspection_reports_status\n""",
+          )
+
+          # 2) A documented company absence is a terminal manifestation: it must not strand a LOCKED Act.
+          closing = 'api-v3/src/inspection-closing/inspection-closing.service.ts'
+          replace_once(
+              closing,
+              """      const companyOutcomes = signatures.filter((item) =>\n        item.signerType === InspectionActSignerType.COMPANY_RESPONSIBLE,\n      );\n      if (companyOutcomes.length !== 1) {\n        throw new ConflictException({\n          code: 'INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED',\n          message: 'Debe existir exactamente una firma, disidencia o negativa del responsable de la empresa',\n        });\n      }\n      const companyOutcome = companyOutcomes[0];\n      if (companyOutcome.status === InspectionActSignatureStatus.ABSENT) {\n        throw new ConflictException({\n          code: 'INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING',\n          message: 'La ausencia no reemplaza la firma o negativa; la manifestación de la empresa sigue pendiente',\n        });\n      }\n\n      const serverSealedAt = new Date();\n""",
+              """      const companyOutcomes = signatures.filter((item) =>\n        item.signerType === InspectionActSignerType.COMPANY_RESPONSIBLE,\n      );\n      if (companyOutcomes.length !== 1) {\n        throw new ConflictException({\n          code: 'INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED',\n          message: 'Debe existir exactamente una firma, disidencia, negativa o ausencia documentada del responsable de la empresa',\n        });\n      }\n\n      const serverSealedAt = new Date();\n""",
+          )
+
+          # 3) Legacy administrative follow-up remains available, but F4 SEALED Acts must be visible.
+          admin = 'api-v3/src/act-administration/act-administration.service.ts'
+          replace_once(
+              admin,
+              "WHERE ia.status IN ('CLOSED', 'RECTIFIED')",
+              "WHERE ia.status IN ('SEALED', 'CLOSED', 'RECTIFIED')",
+          )
+          replace_once(
+              admin,
+              "if (!['CLOSED', 'RECTIFIED'].includes(act.status)) throw new BadRequestException({ code: 'ACT_ADMIN_REQUIRES_CLOSED', message: 'El seguimiento administrativo comienza cuando el Acta está cerrada.' });",
+              "if (!['SEALED', 'CLOSED', 'RECTIFIED'].includes(act.status)) throw new BadRequestException({ code: 'ACT_ADMIN_REQUIRES_SEALED', message: 'El seguimiento administrativo comienza cuando el Acta está sellada.' });",
+          )
+
+          briefing = 'api-v3/src/act-administration/field-briefing.service.ts'
+          replace_once(
+              briefing,
+              "WHERE act.status IN ('CLOSED', 'RECTIFIED')",
+              "WHERE act.status IN ('SEALED', 'CLOSED', 'RECTIFIED')",
+          )
+
+          page = 'web-v2/src/pages/ActAdministrationPage.tsx'
+          replace_once(
+              page,
+              "El plazo y la respuesta de la empresa se gestionan sobre el Acta completa. Los hallazgos quedan dentro de su expediente.",
+              "El plazo y la respuesta de la empresa se gestionan sobre el Acta completa. GEDO no activa el vencimiento por sí solo; el plazo se define cuando corresponda. Los hallazgos quedan dentro de su expediente.",
+          )
+
+          # 4) Regression contracts for the three audited pre-merge gaps.
+          test_path = Path('api-v3/test/unit/f4-premerge-review-contract.test.ts')
+          if test_path.exists():
+              raise SystemExit(f'{test_path}: file already exists')
+          test_path.write_text("""import assert from 'node:assert/strict';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport test from 'node:test';\n\nconst root = process.cwd();\nconst read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');\n\nconst migration = read('src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts');\nconst closing = read('src/inspection-closing/inspection-closing.service.ts');\nconst administration = read('src/act-administration/act-administration.service.ts');\nconst briefing = read('src/act-administration/field-briefing.service.ts');\n\ntest('F4 report status default is WORKING physically and rollback restores FROZEN', () => {\n  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));\n  const down = migration.slice(migration.indexOf('  public async down('));\n  assert.match(up, /ALTER COLUMN status SET DEFAULT 'WORKING'/);\n  assert.match(down, /ALTER COLUMN status SET DEFAULT 'FROZEN'/);\n});\n\ntest('F4 allows a documented company absence to satisfy the terminal manifestation required for sealing', () => {\n  const closeStart = closing.indexOf('  async close(');\n  const closeEnd = closing.indexOf('  async signatureContent(', closeStart);\n  const close = closing.slice(closeStart, closeEnd);\n  assert.match(close, /companyOutcomes\.length !== 1/);\n  assert.match(close, /ausencia documentada/);\n  assert.doesNotMatch(close, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);\n  assert.doesNotMatch(close, /companyOutcome\.status === InspectionActSignatureStatus\.ABSENT/);\n});\n\ntest('F4 SEALED Acts remain visible in administrative follow-up and field briefing', () => {\n  assert.match(administration, /WHERE ia\.status IN \('SEALED', 'CLOSED', 'RECTIFIED'\)/);\n  assert.match(administration, /\['SEALED', 'CLOSED', 'RECTIFIED'\]\.includes\(act\.status\)/);\n  assert.match(briefing, /WHERE act\.status IN \('SEALED', 'CLOSED', 'RECTIFIED'\)/);\n});\n""")
+          PY
+
+          git diff --check
+
+      - name: Commit audited corrections
+        run: |
+          set -Eeuo pipefail
+          if git diff --quiet; then
+            echo 'No changes produced; refusing silent success.'
+            exit 1
+          fi
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git add \
+            api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts \
+            api-v3/src/inspection-closing/inspection-closing.service.ts \
+            api-v3/src/act-administration/act-administration.service.ts \
+            api-v3/src/act-administration/field-briefing.service.ts \
+            api-v3/test/unit/f4-premerge-review-contract.test.ts \
+            web-v2/src/pages/ActAdministrationPage.tsx
+          git commit -m 'fix: close F4 pre-merge review gaps'
+          git push origin HEAD:feature/f4-backend-saneamiento-documental

From 844c1a950fe6e37c01fc6c81e5f7a0c0cf681d6e Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 8 Sep 2026 18:06:16 +0000
Subject: [PATCH 217/224] fix: close F4 pre-merge review gaps

---
 .../act-administration.service.ts             |  4 +--
 .../field-briefing.service.ts                 |  2 +-
 ...f4-align-document-lifecycle-constraints.ts |  8 +++++
 .../inspection-closing.service.ts             |  9 +----
 .../unit/f4-premerge-review-contract.test.ts  | 35 +++++++++++++++++++
 web-v2/src/pages/ActAdministrationPage.tsx    |  2 +-
 6 files changed, 48 insertions(+), 12 deletions(-)
 create mode 100644 api-v3/test/unit/f4-premerge-review-contract.test.ts

diff --git a/api-v3/src/act-administration/act-administration.service.ts b/api-v3/src/act-administration/act-administration.service.ts
index c582b48..38f4e2d 100644
--- a/api-v3/src/act-administration/act-administration.service.ts
+++ b/api-v3/src/act-administration/act-administration.service.ts
@@ -49,7 +49,7 @@ export class ActAdministrationService {
                  COUNT(*) FILTER (WHERE f.status = 'OPEN' AND f.next_control_on IS NOT NULL) AS scheduled_control_count
           FROM inspection_findings f WHERE f.act_id = ia.id
         ) fc ON true
-        WHERE ia.status IN ('CLOSED', 'RECTIFIED')
+        WHERE ia.status IN ('SEALED', 'CLOSED', 'RECTIFIED')
       ), classified AS (
         SELECT *, CASE
           WHEN "findingCount" > 0 AND "openFindingCount" = 0 THEN 'REGULARIZED'
@@ -110,7 +110,7 @@ export class ActAdministrationService {
     const rows = await this.dataSource.query(`SELECT id, code, status FROM inspection_acts WHERE id = $1`, [actId]);
     const act = rows[0];
     if (!act) throw new NotFoundException({ code: 'ACT_NOT_FOUND', message: 'Acta inexistente.' });
-    if (!['CLOSED', 'RECTIFIED'].includes(act.status)) throw new BadRequestException({ code: 'ACT_ADMIN_REQUIRES_CLOSED', message: 'El seguimiento administrativo comienza cuando el Acta está cerrada.' });
+    if (!['SEALED', 'CLOSED', 'RECTIFIED'].includes(act.status)) throw new BadRequestException({ code: 'ACT_ADMIN_REQUIRES_SEALED', message: 'El seguimiento administrativo comienza cuando el Acta está sellada.' });
     return act;
   }
 
diff --git a/api-v3/src/act-administration/field-briefing.service.ts b/api-v3/src/act-administration/field-briefing.service.ts
index c718ca8..5b7f917 100644
--- a/api-v3/src/act-administration/field-briefing.service.ts
+++ b/api-v3/src/act-administration/field-briefing.service.ts
@@ -129,7 +129,7 @@ export class FieldBriefingService {
           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')
+        WHERE act.status IN ('SEALED', 'CLOSED', 'RECTIFIED')
           AND source_visit.id <> $1
           AND source_visit.operational_area_id = $2::uuid
           AND source_visit.operator_company_id = $3::uuid
diff --git a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
index 6171183..2a6a81b 100644
--- a/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
+++ b/api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts
@@ -22,6 +22,10 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
         status IN ('WORKING','OFFICIALIZED','FROZEN','CANCELLED')
       )
     `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_reports
+      ALTER COLUMN status SET DEFAULT 'WORKING'
+    `);
 
     await queryRunner.query(`
       ALTER TABLE inspection_acts
@@ -163,6 +167,10 @@ export class F4AlignDocumentLifecycleConstraints1790000600000 implements Migrati
       SET status='FROZEN'
       WHERE status IN ('WORKING','OFFICIALIZED')
     `);
+    await queryRunner.query(`
+      ALTER TABLE inspection_reports
+      ALTER COLUMN status SET DEFAULT 'FROZEN'
+    `);
     await queryRunner.query(`
       ALTER TABLE inspection_reports
       DROP CONSTRAINT IF EXISTS chk_inspection_reports_status
diff --git a/api-v3/src/inspection-closing/inspection-closing.service.ts b/api-v3/src/inspection-closing/inspection-closing.service.ts
index 253a4e4..be1c906 100644
--- a/api-v3/src/inspection-closing/inspection-closing.service.ts
+++ b/api-v3/src/inspection-closing/inspection-closing.service.ts
@@ -549,14 +549,7 @@ export class InspectionClosingService {
       if (companyOutcomes.length !== 1) {
         throw new ConflictException({
           code: 'INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED',
-          message: 'Debe existir exactamente una firma, disidencia o negativa del responsable de la empresa',
-        });
-      }
-      const companyOutcome = companyOutcomes[0];
-      if (companyOutcome.status === InspectionActSignatureStatus.ABSENT) {
-        throw new ConflictException({
-          code: 'INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING',
-          message: 'La ausencia no reemplaza la firma o negativa; la manifestación de la empresa sigue pendiente',
+          message: 'Debe existir exactamente una firma, disidencia, negativa o ausencia documentada del responsable de la empresa',
         });
       }
 
diff --git a/api-v3/test/unit/f4-premerge-review-contract.test.ts b/api-v3/test/unit/f4-premerge-review-contract.test.ts
new file mode 100644
index 0000000..a6a5700
--- /dev/null
+++ b/api-v3/test/unit/f4-premerge-review-contract.test.ts
@@ -0,0 +1,35 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = process.cwd();
+const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
+
+const migration = read('src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts');
+const closing = read('src/inspection-closing/inspection-closing.service.ts');
+const administration = read('src/act-administration/act-administration.service.ts');
+const briefing = read('src/act-administration/field-briefing.service.ts');
+
+test('F4 report status default is WORKING physically and rollback restores FROZEN', () => {
+  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));
+  const down = migration.slice(migration.indexOf('  public async down('));
+  assert.match(up, /ALTER COLUMN status SET DEFAULT 'WORKING'/);
+  assert.match(down, /ALTER COLUMN status SET DEFAULT 'FROZEN'/);
+});
+
+test('F4 allows a documented company absence to satisfy the terminal manifestation required for sealing', () => {
+  const closeStart = closing.indexOf('  async close(');
+  const closeEnd = closing.indexOf('  async signatureContent(', closeStart);
+  const close = closing.slice(closeStart, closeEnd);
+  assert.match(close, /companyOutcomes\.length !== 1/);
+  assert.match(close, /ausencia documentada/);
+  assert.doesNotMatch(close, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);
+  assert.doesNotMatch(close, /companyOutcome\.status === InspectionActSignatureStatus\.ABSENT/);
+});
+
+test('F4 SEALED Acts remain visible in administrative follow-up and field briefing', () => {
+  assert.match(administration, /WHERE ia\.status IN \('SEALED', 'CLOSED', 'RECTIFIED'\)/);
+  assert.match(administration, /\['SEALED', 'CLOSED', 'RECTIFIED'\]\.includes\(act\.status\)/);
+  assert.match(briefing, /WHERE act\.status IN \('SEALED', 'CLOSED', 'RECTIFIED'\)/);
+});
diff --git a/web-v2/src/pages/ActAdministrationPage.tsx b/web-v2/src/pages/ActAdministrationPage.tsx
index aadfe6e..6a860b5 100644
--- a/web-v2/src/pages/ActAdministrationPage.tsx
+++ b/web-v2/src/pages/ActAdministrationPage.tsx
@@ -16,7 +16,7 @@ const label=(s:ActAdministrationState)=>states.find(x=>x.value===s)?.label??s;
 export function ActAdministrationPage(){
  const ctx=useOperationalContext(); const [state,setState]=useState<'ALL'|ActAdministrationState>('ALL'); const [items,setItems]=useState<ActAdministrationQueueItem[]>([]); const [meta,setMeta]=useState<PageMeta>({page:1,pageSize:25,total:0,totalPages:0}); const [counters,setCounters]=useState<Partial<Record<ActAdministrationState,number>>>({}); const [loading,setLoading]=useState(true); const [error,setError]=useState('');
  useEffect(()=>{setLoading(true);setError('');listActAdministrationQueue({state,areaId:ctx.areaId||undefined,companyId:ctx.companyId||undefined,page:1,pageSize:50}).then(r=>{setItems(r.data);setMeta(r.meta);setCounters(r.counters)}).catch(e=>setError(errorMessage(e))).finally(()=>setLoading(false));},[state,ctx.areaId,ctx.companyId]);
- return <section><div className="page-heading"><div><span className="eyebrow">SEGUIMIENTO ADMINISTRATIVO</span><h1>Seguimiento de Actas</h1><p>El plazo y la respuesta de la empresa se gestionan sobre el Acta completa. Los hallazgos quedan dentro de su expediente.</p></div></div>
+ return <section><div className="page-heading"><div><span className="eyebrow">SEGUIMIENTO ADMINISTRATIVO</span><h1>Seguimiento de Actas</h1><p>El plazo y la respuesta de la empresa se gestionan sobre el Acta completa. GEDO no activa el vencimiento por sí solo; el plazo se define cuando corresponda. Los hallazgos quedan dentro de su expediente.</p></div></div>
  <div className="status-tabs">{states.map(s=><button key={s.value} className={state===s.value?'active':''} onClick={()=>setState(s.value)}>{s.label}{s.value!=='ALL'&&<small>{counters[s.value]??0}</small>}</button>)}</div>
  {error&&<Alert>{error}</Alert>}{loading?<LoadingBlock label="Cargando seguimiento…"/>:items.length===0?<EmptyState title="Sin actas" text="No hay actas en este estado para el contexto seleccionado."/>:<div className="table-panel"><div className="table-summary"><strong>{meta.total} acta{meta.total===1?'':'s'}</strong></div><div className="table-scroll"><table><thead><tr><th>Acta</th><th>Área / empresa</th><th>Hallazgos</th><th>Plazo empresa</th><th>Respuesta</th><th>Estado</th><th/></tr></thead><tbody>{items.map(a=><tr key={a.actId}><td><strong>{a.actCode}</strong><small className="block-muted">{formatDate(a.occurredAt)}</small></td><td><strong>{a.areaName??'—'}</strong><small className="block-muted">{a.companyName??'—'}</small></td><td>{a.openFindingCount} abiertos / {a.findingCount}</td><td>{a.responseDueOn?formatDate(a.responseDueOn):'Sin definir'}</td><td>{a.responseReceivedOn?formatDate(a.responseReceivedOn):'Pendiente'}</td><td><span className={`status-badge ${a.adminState==='OVERDUE'||a.adminState==='COMMITMENT_OVERDUE'?'danger':'pending'}`}>{label(a.adminState)}</span></td><td><Link className="button secondary" to={`/seguimiento-actas/${a.actId}`}>Gestionar</Link></td></tr>)}</tbody></table></div></div>}</section>;
 }

From fcd64d5f439be9f7d026dbe2560b41fe03af5968 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 15:07:03 -0300
Subject: [PATCH 218/224] chore: remove one-shot F4 patch workflow

---
 .../workflows/f4-one-shot-premerge-fix.yml    | 107 ------------------
 1 file changed, 107 deletions(-)
 delete mode 100644 .github/workflows/f4-one-shot-premerge-fix.yml

diff --git a/.github/workflows/f4-one-shot-premerge-fix.yml b/.github/workflows/f4-one-shot-premerge-fix.yml
deleted file mode 100644
index 884f59f..0000000
--- a/.github/workflows/f4-one-shot-premerge-fix.yml
+++ /dev/null
@@ -1,107 +0,0 @@
-name: F4 one-shot pre-merge corrections
-
-on:
-  push:
-    branches:
-      - feature/f4-backend-saneamiento-documental
-
-permissions:
-  contents: write
-
-jobs:
-  patch:
-    if: github.actor != 'github-actions[bot]'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: feature/f4-backend-saneamiento-documental
-
-      - name: Apply audited F4 corrections
-        run: |
-          python - <<'PY'
-          from pathlib import Path
-
-          def replace_once(path: str, old: str, new: str) -> None:
-              file = Path(path)
-              text = file.read_text()
-              count = text.count(old)
-              if count != 1:
-                  raise SystemExit(f"{path}: expected exactly one match, got {count}")
-              file.write_text(text.replace(old, new))
-
-          # 1) Physical DB default must match the active F4 report lifecycle.
-          migration = 'api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts'
-          replace_once(
-              migration,
-              """    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ADD CONSTRAINT chk_inspection_reports_status CHECK (\n        status IN ('WORKING','OFFICIALIZED','FROZEN','CANCELLED')\n      )\n    `);\n\n    await queryRunner.query(`\n      ALTER TABLE inspection_acts\n""",
-              """    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ADD CONSTRAINT chk_inspection_reports_status CHECK (\n        status IN ('WORKING','OFFICIALIZED','FROZEN','CANCELLED')\n      )\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ALTER COLUMN status SET DEFAULT 'WORKING'\n    `);\n\n    await queryRunner.query(`\n      ALTER TABLE inspection_acts\n""",
-          )
-          replace_once(
-              migration,
-              """    await queryRunner.query(`\n      UPDATE inspection_reports\n      SET status='FROZEN'\n      WHERE status IN ('WORKING','OFFICIALIZED')\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      DROP CONSTRAINT IF EXISTS chk_inspection_reports_status\n""",
-              """    await queryRunner.query(`\n      UPDATE inspection_reports\n      SET status='FROZEN'\n      WHERE status IN ('WORKING','OFFICIALIZED')\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      ALTER COLUMN status SET DEFAULT 'FROZEN'\n    `);\n    await queryRunner.query(`\n      ALTER TABLE inspection_reports\n      DROP CONSTRAINT IF EXISTS chk_inspection_reports_status\n""",
-          )
-
-          # 2) A documented company absence is a terminal manifestation: it must not strand a LOCKED Act.
-          closing = 'api-v3/src/inspection-closing/inspection-closing.service.ts'
-          replace_once(
-              closing,
-              """      const companyOutcomes = signatures.filter((item) =>\n        item.signerType === InspectionActSignerType.COMPANY_RESPONSIBLE,\n      );\n      if (companyOutcomes.length !== 1) {\n        throw new ConflictException({\n          code: 'INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED',\n          message: 'Debe existir exactamente una firma, disidencia o negativa del responsable de la empresa',\n        });\n      }\n      const companyOutcome = companyOutcomes[0];\n      if (companyOutcome.status === InspectionActSignatureStatus.ABSENT) {\n        throw new ConflictException({\n          code: 'INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING',\n          message: 'La ausencia no reemplaza la firma o negativa; la manifestación de la empresa sigue pendiente',\n        });\n      }\n\n      const serverSealedAt = new Date();\n""",
-              """      const companyOutcomes = signatures.filter((item) =>\n        item.signerType === InspectionActSignerType.COMPANY_RESPONSIBLE,\n      );\n      if (companyOutcomes.length !== 1) {\n        throw new ConflictException({\n          code: 'INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED',\n          message: 'Debe existir exactamente una firma, disidencia, negativa o ausencia documentada del responsable de la empresa',\n        });\n      }\n\n      const serverSealedAt = new Date();\n""",
-          )
-
-          # 3) Legacy administrative follow-up remains available, but F4 SEALED Acts must be visible.
-          admin = 'api-v3/src/act-administration/act-administration.service.ts'
-          replace_once(
-              admin,
-              "WHERE ia.status IN ('CLOSED', 'RECTIFIED')",
-              "WHERE ia.status IN ('SEALED', 'CLOSED', 'RECTIFIED')",
-          )
-          replace_once(
-              admin,
-              "if (!['CLOSED', 'RECTIFIED'].includes(act.status)) throw new BadRequestException({ code: 'ACT_ADMIN_REQUIRES_CLOSED', message: 'El seguimiento administrativo comienza cuando el Acta está cerrada.' });",
-              "if (!['SEALED', 'CLOSED', 'RECTIFIED'].includes(act.status)) throw new BadRequestException({ code: 'ACT_ADMIN_REQUIRES_SEALED', message: 'El seguimiento administrativo comienza cuando el Acta está sellada.' });",
-          )
-
-          briefing = 'api-v3/src/act-administration/field-briefing.service.ts'
-          replace_once(
-              briefing,
-              "WHERE act.status IN ('CLOSED', 'RECTIFIED')",
-              "WHERE act.status IN ('SEALED', 'CLOSED', 'RECTIFIED')",
-          )
-
-          page = 'web-v2/src/pages/ActAdministrationPage.tsx'
-          replace_once(
-              page,
-              "El plazo y la respuesta de la empresa se gestionan sobre el Acta completa. Los hallazgos quedan dentro de su expediente.",
-              "El plazo y la respuesta de la empresa se gestionan sobre el Acta completa. GEDO no activa el vencimiento por sí solo; el plazo se define cuando corresponda. Los hallazgos quedan dentro de su expediente.",
-          )
-
-          # 4) Regression contracts for the three audited pre-merge gaps.
-          test_path = Path('api-v3/test/unit/f4-premerge-review-contract.test.ts')
-          if test_path.exists():
-              raise SystemExit(f'{test_path}: file already exists')
-          test_path.write_text("""import assert from 'node:assert/strict';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport test from 'node:test';\n\nconst root = process.cwd();\nconst read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');\n\nconst migration = read('src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts');\nconst closing = read('src/inspection-closing/inspection-closing.service.ts');\nconst administration = read('src/act-administration/act-administration.service.ts');\nconst briefing = read('src/act-administration/field-briefing.service.ts');\n\ntest('F4 report status default is WORKING physically and rollback restores FROZEN', () => {\n  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));\n  const down = migration.slice(migration.indexOf('  public async down('));\n  assert.match(up, /ALTER COLUMN status SET DEFAULT 'WORKING'/);\n  assert.match(down, /ALTER COLUMN status SET DEFAULT 'FROZEN'/);\n});\n\ntest('F4 allows a documented company absence to satisfy the terminal manifestation required for sealing', () => {\n  const closeStart = closing.indexOf('  async close(');\n  const closeEnd = closing.indexOf('  async signatureContent(', closeStart);\n  const close = closing.slice(closeStart, closeEnd);\n  assert.match(close, /companyOutcomes\.length !== 1/);\n  assert.match(close, /ausencia documentada/);\n  assert.doesNotMatch(close, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);\n  assert.doesNotMatch(close, /companyOutcome\.status === InspectionActSignatureStatus\.ABSENT/);\n});\n\ntest('F4 SEALED Acts remain visible in administrative follow-up and field briefing', () => {\n  assert.match(administration, /WHERE ia\.status IN \('SEALED', 'CLOSED', 'RECTIFIED'\)/);\n  assert.match(administration, /\['SEALED', 'CLOSED', 'RECTIFIED'\]\.includes\(act\.status\)/);\n  assert.match(briefing, /WHERE act\.status IN \('SEALED', 'CLOSED', 'RECTIFIED'\)/);\n});\n""")
-          PY
-
-          git diff --check
-
-      - name: Commit audited corrections
-        run: |
-          set -Eeuo pipefail
-          if git diff --quiet; then
-            echo 'No changes produced; refusing silent success.'
-            exit 1
-          fi
-          git config user.name 'github-actions[bot]'
-          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
-          git add \
-            api-v3/src/database/migrations/1790000600000-f4-align-document-lifecycle-constraints.ts \
-            api-v3/src/inspection-closing/inspection-closing.service.ts \
-            api-v3/src/act-administration/act-administration.service.ts \
-            api-v3/src/act-administration/field-briefing.service.ts \
-            api-v3/test/unit/f4-premerge-review-contract.test.ts \
-            web-v2/src/pages/ActAdministrationPage.tsx
-          git commit -m 'fix: close F4 pre-merge review gaps'
-          git push origin HEAD:feature/f4-backend-saneamiento-documental

From 2121df0b552f2708d1e5cddd5536a5069b73f3a1 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 15:10:01 -0300
Subject: [PATCH 219/224] test: align F4 sealing contract with documented
 absence

---
 api-v3/test/unit/f4-multi-act-lifecycle.test.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
index 93c6a4c..60ae06e 100644
--- a/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
+++ b/api-v3/test/unit/f4-multi-act-lifecycle.test.ts
@@ -80,13 +80,13 @@ test('F4 field finding flow only targets a draft act of the same in-progress ins
   assert.match(draftGuard, /WHERE visit_id = \$1::uuid[\s\S]*AND status = 'DRAFT'/);
 });
 
-test('F4 sealing requires inspector signature and exactly one resolved company manifestation', () => {
+test('F4 sealing requires inspector signature and exactly one terminal company outcome', () => {
   const closeBody = closing.slice(closing.indexOf('  async close('), closing.indexOf('  async signatureContent('));
   assert.match(closeBody, /INSPECTION_ACT_INSPECTOR_SIGNATURE_REQUIRED/);
   assert.match(closeBody, /companyOutcomes\.length !== 1/);
   assert.match(closeBody, /INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED/);
-  assert.match(closeBody, /InspectionActSignatureStatus\.ABSENT/);
-  assert.match(closeBody, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);
+  assert.match(closeBody, /ausencia documentada/);
+  assert.doesNotMatch(closeBody, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);
   assert.match(closeBody, /status='SEALED'/);
 });
 

From 4c47916bd18687e2cabf9343059cef786a3ff4fa Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 15:10:18 -0300
Subject: [PATCH 220/224] test: update multi-act company outcome semantics

---
 .../unit/phase-f1-1-multi-act-operating-model.test.ts    | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts b/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts
index 99beaa5..56bfb93 100644
--- a/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts
+++ b/api-v3/test/unit/phase-f1-1-multi-act-operating-model.test.ts
@@ -45,10 +45,13 @@ test('F4 closes an inspection only after every non-cancelled act is sealed', ()
   assert.match(closeBody, /visit\.status = InspectionVisitStatus\.CLOSED/);
 });
 
-test('F4 requires a final company manifestation before an act can be sealed', () => {
+test('F4 requires exactly one terminal company outcome before an act can be sealed', () => {
   const closing = read('src/inspection-closing/inspection-closing.service.ts');
-  assert.match(closing, /INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED/);
-  assert.match(closing, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);
+  const closeBody = closing.slice(closing.indexOf('  async close('), closing.indexOf('  async signatureContent('));
+  assert.match(closeBody, /companyOutcomes\.length !== 1/);
+  assert.match(closeBody, /INSPECTION_ACT_COMPANY_OUTCOME_REQUIRED/);
+  assert.match(closeBody, /ausencia documentada/);
+  assert.doesNotMatch(closeBody, /INSPECTION_ACT_COMPANY_MANIFESTATION_PENDING/);
   assert.match(closing, /InspectionCompanySignatureManifestation\.CONFORMITY/);
   assert.match(closing, /InspectionCompanySignatureManifestation\.DISSENT/);
   assert.match(closing, /InspectionActSignatureStatus\.REFUSED/);

From 969ffddc76c6a2f0e7c7e7251c549a804a5284c9 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 15:21:54 -0300
Subject: [PATCH 221/224] chore: stage final F4 review fixes

---
 .../f4-one-shot-final-review-fix.yml          | 134 ++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 .github/workflows/f4-one-shot-final-review-fix.yml

diff --git a/.github/workflows/f4-one-shot-final-review-fix.yml b/.github/workflows/f4-one-shot-final-review-fix.yml
new file mode 100644
index 0000000..5986332
--- /dev/null
+++ b/.github/workflows/f4-one-shot-final-review-fix.yml
@@ -0,0 +1,134 @@
+name: F4 one-shot final review fixes
+
+on:
+  push:
+    branches:
+      - feature/f4-backend-saneamiento-documental
+
+permissions:
+  contents: write
+
+jobs:
+  patch:
+    if: github.actor != 'github-actions[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: feature/f4-backend-saneamiento-documental
+
+      - name: Apply final audited F4 corrections
+        run: |
+          python - <<'PY'
+          from pathlib import Path
+
+          def replace_once(path: str, old: str, new: str) -> None:
+              file = Path(path)
+              text = file.read_text()
+              count = text.count(old)
+              if count != 1:
+                  raise SystemExit(f"{path}: expected exactly one match, got {count}")
+              file.write_text(text.replace(old, new))
+
+          workflow = 'api-v3/src/inspection-reports/inspection-report-workflow.service.ts'
+          replace_once(
+              workflow,
+              "import { mkdir, unlink, writeFile } from 'node:fs/promises';",
+              "import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';",
+          )
+          replace_once(
+              workflow,
+              """  ConflictException,\n  Injectable,\n  NotFoundException,\n""",
+              """  ConflictException,\n  Injectable,\n  InternalServerErrorException,\n  NotFoundException,\n""",
+          )
+          replace_once(
+              workflow,
+              "?? '/app/storage/inspection-reports';",
+              "?? '/app/storage/asset-media/inspection-reports';",
+          )
+          replace_once(
+              workflow,
+              """      await manager.query(`\n        UPDATE inspection_reports\n        SET executive_summary=$2,\n            report_description=$3,\n            updated_at=CURRENT_TIMESTAMP\n        WHERE id=$1\n      `, [reportId, executiveSummary, reportDescription]);\n""",
+              """      await manager.query(`\n        UPDATE inspection_reports\n        SET executive_summary=$2,\n            report_description=$3,\n            word_status=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN 'PENDING' ELSE word_status END,\n            word_original_name=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_original_name END,\n            word_stored_name=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_stored_name END,\n            word_mime_type=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_mime_type END,\n            word_size_bytes=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_size_bytes END,\n            word_sha256=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_sha256 END,\n            word_generated_at=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_generated_at END,\n            word_error=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_error END,\n            updated_at=CURRENT_TIMESTAMP\n        WHERE id=$1\n      `, [reportId, executiveSummary, reportDescription]);\n""",
+          )
+          replace_once(
+              workflow,
+              """  async addFollowUp(\n""",
+              """  async officialPdfContent(reportId: string): Promise<{ filePath: string; originalName: string; mimeType: string }> {\n    const [row] = await this.dataSource.query(`\n      SELECT\n        gedo_pdf_original_name AS \"originalName\",\n        gedo_pdf_stored_name AS \"storedName\",\n        gedo_pdf_mime_type AS \"mimeType\",\n        gedo_pdf_size_bytes::integer AS \"sizeBytes\",\n        gedo_pdf_sha256 AS sha256\n      FROM inspection_reports\n      WHERE id=$1\n    `, [reportId]) as Array<{\n      originalName: string | null;\n      storedName: string | null;\n      mimeType: string | null;\n      sizeBytes: number | null;\n      sha256: string | null;\n    }>;\n    if (!row) throw reportNotFound();\n    if (!row.originalName || !row.storedName || !row.sizeBytes || !row.sha256) {\n      throw new NotFoundException({\n        code: 'INSPECTION_REPORT_GEDO_PDF_NOT_AVAILABLE',\n        message: 'El PDF oficial de GEDO todavía no está disponible',\n      });\n    }\n    const filePath = resolve(this.root, row.storedName);\n    if (filePath === this.root || !filePath.startsWith(`${this.root}/`)) throw this.reportStorageError();\n    const fileStat = await stat(filePath).catch(() => null);\n    if (!fileStat?.isFile() || fileStat.size !== row.sizeBytes) throw this.reportStorageError();\n    const buffer = await readFile(filePath);\n    const sha256 = createHash('sha256').update(buffer).digest('hex');\n    if (sha256 !== row.sha256) throw this.reportStorageError();\n    return {\n      filePath,\n      originalName: row.originalName,\n      mimeType: row.mimeType ?? 'application/pdf',\n    };\n  }\n\n  async addFollowUp(\n""",
+          )
+          replace_once(
+              workflow,
+              """  private assertPdf(file: UploadedInspectionReportFile | undefined): void {\n""",
+              """  private reportStorageError(): InternalServerErrorException {\n    return new InternalServerErrorException({\n      code: 'INSPECTION_REPORT_GEDO_PDF_STORAGE_ERROR',\n      message: 'El PDF oficial de GEDO no está disponible o no supera la validación de integridad',\n    });\n  }\n\n  private assertPdf(file: UploadedInspectionReportFile | undefined): void {\n""",
+          )
+
+          word = 'api-v3/src/inspection-reports/inspection-report-word.service.ts'
+          replace_once(
+              word,
+              "const storedName = `${row.id}.docx`;",
+              "const storedName = `${row.id}-${built.sha256.slice(0, 16)}.docx`;",
+          )
+
+          compose = 'docker-compose.yml'
+          replace_once(
+              compose,
+              """      INSPECTION_REPORT_WORD_ROOT: /app/storage/asset-media/inspection-reports-word\n""",
+              """      INSPECTION_REPORT_UPLOAD_ROOT: /app/storage/asset-media/inspection-reports\n      INSPECTION_REPORT_WORD_ROOT: /app/storage/asset-media/inspection-reports-word\n""",
+          )
+
+          controller = 'api-v3/src/inspection-reports/inspection-reports.controller.ts'
+          replace_once(
+              controller,
+              """  @Patch(':id')\n""",
+              """  @Get(':id/gedo-pdf')\n  @RequirePermissions('inspection_reports.read')\n  async gedoPdfContent(\n    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,\n    @Res() response: Response,\n  ) {\n    const content = await this.workflow.officialPdfContent(id);\n    response.setHeader('Content-Type', content.mimeType);\n    response.setHeader('Content-Disposition', `attachment; filename=\"${content.originalName.replaceAll('\\\"', '')}\"`);\n    return response.sendFile(content.filePath);\n  }\n\n  @Patch(':id')\n""",
+          )
+
+          web_api = 'web-v2/src/lib/reportWorkflowApi.ts'
+          replace_once(
+              web_api,
+              """export function inspectionReportWordDownloadUrl(id: string) {\n  return `/api/v3/inspection-reports/${id}/word`;\n}\n""",
+              """export function inspectionReportWordDownloadUrl(id: string) {\n  return `/api/v3/inspection-reports/${id}/word`;\n}\n\nexport function inspectionReportGedoPdfDownloadUrl(id: string) {\n  return `/api/v3/inspection-reports/${id}/gedo-pdf`;\n}\n""",
+          )
+
+          page = 'web-v2/src/pages/ReportDetailPage.tsx'
+          replace_once(
+              page,
+              """  getInspectionReportF4,\n  inspectionReportWordDownloadUrl,\n""",
+              """  getInspectionReportF4,\n  inspectionReportGedoPdfDownloadUrl,\n  inspectionReportWordDownloadUrl,\n""",
+          )
+          replace_once(
+              page,
+              """          {report.gedoPdfSha256 && <div className=\"temporal-notice\"><Icon name=\"check\" /><p><strong>PDF GEDO fijado.</strong> SHA-256: <code>{report.gedoPdfSha256}</code></p></div>}\n""",
+              """          {report.gedoPdfOriginalName && <div className=\"form-actions\"><a className=\"button secondary\" href={inspectionReportGedoPdfDownloadUrl(report.id)}>Descargar PDF oficial</a></div>}\n          {report.gedoPdfSha256 && <div className=\"temporal-notice\"><Icon name=\"check\" /><p><strong>PDF GEDO fijado.</strong> SHA-256: <code>{report.gedoPdfSha256}</code></p></div>}\n""",
+          )
+
+          migration = Path('api-v3/src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts')
+          if migration.exists():
+              raise SystemExit(f'{migration}: file already exists')
+          migration.write_text("""import { MigrationInterface, QueryRunner } from 'typeorm';\n\nexport class F4AlignAssetVersionFunctionChange1790000700000 implements MigrationInterface {\n  name = 'F4AlignAssetVersionFunctionChange1790000700000';\n\n  public async up(queryRunner: QueryRunner): Promise<void> {\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      DROP CONSTRAINT IF EXISTS chk_asset_versions_change_type\n    `);\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      ADD CONSTRAINT chk_asset_versions_change_type CHECK (change_type IN (\n        'BASELINE', 'CREATED', 'UPDATED', 'CONTEXT_CHANGED', 'FUNCTION_CHANGED',\n        'STATUS_CHANGED', 'OPERATIONAL_STATUS_CHANGED', 'REGISTRY_UPDATED',\n        'GEOMETRY_UPDATED', 'GEOMETRY_REMOVED',\n        'MEDIA_UPLOADED', 'MEDIA_UPDATED', 'MEDIA_REMOVED',\n        'PROVENANCE_BASELINE', 'PROVENANCE_UPDATED', 'PROVENANCE_VERIFIED'\n      ))\n    `);\n  }\n\n  public async down(queryRunner: QueryRunner): Promise<void> {\n    await queryRunner.query(`\n      UPDATE asset_versions\n      SET change_type='UPDATED'\n      WHERE change_type='FUNCTION_CHANGED'\n    `);\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      DROP CONSTRAINT IF EXISTS chk_asset_versions_change_type\n    `);\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      ADD CONSTRAINT chk_asset_versions_change_type CHECK (change_type IN (\n        'BASELINE', 'CREATED', 'UPDATED', 'CONTEXT_CHANGED',\n        'STATUS_CHANGED', 'OPERATIONAL_STATUS_CHANGED', 'REGISTRY_UPDATED',\n        'GEOMETRY_UPDATED', 'GEOMETRY_REMOVED',\n        'MEDIA_UPLOADED', 'MEDIA_UPDATED', 'MEDIA_REMOVED',\n        'PROVENANCE_BASELINE', 'PROVENANCE_UPDATED', 'PROVENANCE_VERIFIED'\n      ))\n    `);\n  }\n}\n""")
+
+          test_path = Path('api-v3/test/unit/f4-final-review-contract.test.ts')
+          if test_path.exists():
+              raise SystemExit(f'{test_path}: file already exists')
+          test_path.write_text("""import assert from 'node:assert/strict';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport test from 'node:test';\n\nconst root = process.cwd();\nconst read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');\n\nconst migration = read('src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts');\nconst workflow = read('src/inspection-reports/inspection-report-workflow.service.ts');\nconst word = read('src/inspection-reports/inspection-report-word.service.ts');\nconst controller = read('src/inspection-reports/inspection-reports.controller.ts');\nconst compose = read('../docker-compose.yml');\nconst webApi = read('../web-v2/src/lib/reportWorkflowApi.ts');\nconst reportPage = read('../web-v2/src/pages/ReportDetailPage.tsx');\n\ntest('F4 physically permits FUNCTION_CHANGED asset versions with a reversible downgrade', () => {\n  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));\n  const down = migration.slice(migration.indexOf('  public async down('));\n  assert.match(up, /FUNCTION_CHANGED/);\n  assert.match(down, /SET change_type='UPDATED'[\\s\\S]*WHERE change_type='FUNCTION_CHANGED'/);\n});\n\ntest('F4 GEDO and follow-up uploads stay under the persisted asset-media volume', () => {\n  assert.match(workflow, /\\?\\? '\\/app\\/storage\\/asset-media\\/inspection-reports'/);\n  assert.match(compose, /INSPECTION_REPORT_UPLOAD_ROOT: \\/app\\/storage\\/asset-media\\/inspection-reports/);\n  assert.match(compose, /dhv2_asset_media:\\/app\\/storage\\/asset-media/);\n});\n\ntest('F4 narrative edits invalidate the current generated Word without overwriting its historical file', () => {\n  const update = workflow.slice(workflow.indexOf('  async updateNarrative('), workflow.indexOf('  async officialize('));\n  assert.match(update, /word_status=CASE[\\s\\S]*THEN 'PENDING'/);\n  assert.match(update, /word_stored_name=CASE[\\s\\S]*THEN NULL/);\n  assert.match(update, /word_sha256=CASE[\\s\\S]*THEN NULL/);\n  assert.match(word, /built\\.sha256\\.slice\\(0, 16\\)/);\n});\n\ntest('F4 exposes the immutable official GEDO PDF through a protected integrity-checked download', () => {\n  assert.match(controller, /@Get\\(':id\\/gedo-pdf'\\)[\\s\\S]*@RequirePermissions\\('inspection_reports\\.read'\\)/);\n  assert.match(controller, /this\\.workflow\\.officialPdfContent\\(id\\)/);\n  assert.match(workflow, /async officialPdfContent\\(/);\n  assert.match(workflow, /fileStat\\.size !== row\\.sizeBytes/);\n  assert.match(workflow, /createHash\\('sha256'\\)\\.update\\(buffer\\)\\.digest\\('hex'\\)/);\n  assert.match(webApi, /inspectionReportGedoPdfDownloadUrl/);\n  assert.match(reportPage, /Descargar PDF oficial/);\n});\n""")
+
+          helper = Path('.github/workflows/f4-one-shot-final-review-fix.yml')
+          if not helper.exists():
+              raise SystemExit('one-shot helper workflow is missing')
+          helper.unlink()
+          PY
+
+          git diff --check
+
+      - name: Commit final audited corrections
+        run: |
+          set -Eeuo pipefail
+          if git diff --quiet; then
+            echo 'No changes produced; refusing silent success.'
+            exit 1
+          fi
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git add -A
+          git commit -m 'fix: close final F4 review gaps'
+          git push origin HEAD:feature/f4-backend-saneamiento-documental

From 5dc7ea037d8e68105231707de1e6dbf8cad8b65f Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 8 Sep 2026 18:22:02 +0000
Subject: [PATCH 222/224] fix: close final F4 review gaps

---
 .../f4-one-shot-final-review-fix.yml          | 134 ------------------
 ...-f4-align-asset-version-function-change.ts |  44 ++++++
 .../inspection-report-word.service.ts         |   2 +-
 .../inspection-report-workflow.service.ts     |  74 +++++++++-
 .../inspection-reports.controller.ts          |  12 ++
 .../unit/f4-final-review-contract.test.ts     |  46 ++++++
 docker-compose.yml                            |   1 +
 web-v2/src/lib/reportWorkflowApi.ts           |   4 +
 web-v2/src/pages/ReportDetailPage.tsx         |   2 +
 9 files changed, 182 insertions(+), 137 deletions(-)
 delete mode 100644 .github/workflows/f4-one-shot-final-review-fix.yml
 create mode 100644 api-v3/src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts
 create mode 100644 api-v3/test/unit/f4-final-review-contract.test.ts

diff --git a/.github/workflows/f4-one-shot-final-review-fix.yml b/.github/workflows/f4-one-shot-final-review-fix.yml
deleted file mode 100644
index 5986332..0000000
--- a/.github/workflows/f4-one-shot-final-review-fix.yml
+++ /dev/null
@@ -1,134 +0,0 @@
-name: F4 one-shot final review fixes
-
-on:
-  push:
-    branches:
-      - feature/f4-backend-saneamiento-documental
-
-permissions:
-  contents: write
-
-jobs:
-  patch:
-    if: github.actor != 'github-actions[bot]'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: feature/f4-backend-saneamiento-documental
-
-      - name: Apply final audited F4 corrections
-        run: |
-          python - <<'PY'
-          from pathlib import Path
-
-          def replace_once(path: str, old: str, new: str) -> None:
-              file = Path(path)
-              text = file.read_text()
-              count = text.count(old)
-              if count != 1:
-                  raise SystemExit(f"{path}: expected exactly one match, got {count}")
-              file.write_text(text.replace(old, new))
-
-          workflow = 'api-v3/src/inspection-reports/inspection-report-workflow.service.ts'
-          replace_once(
-              workflow,
-              "import { mkdir, unlink, writeFile } from 'node:fs/promises';",
-              "import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';",
-          )
-          replace_once(
-              workflow,
-              """  ConflictException,\n  Injectable,\n  NotFoundException,\n""",
-              """  ConflictException,\n  Injectable,\n  InternalServerErrorException,\n  NotFoundException,\n""",
-          )
-          replace_once(
-              workflow,
-              "?? '/app/storage/inspection-reports';",
-              "?? '/app/storage/asset-media/inspection-reports';",
-          )
-          replace_once(
-              workflow,
-              """      await manager.query(`\n        UPDATE inspection_reports\n        SET executive_summary=$2,\n            report_description=$3,\n            updated_at=CURRENT_TIMESTAMP\n        WHERE id=$1\n      `, [reportId, executiveSummary, reportDescription]);\n""",
-              """      await manager.query(`\n        UPDATE inspection_reports\n        SET executive_summary=$2,\n            report_description=$3,\n            word_status=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN 'PENDING' ELSE word_status END,\n            word_original_name=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_original_name END,\n            word_stored_name=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_stored_name END,\n            word_mime_type=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_mime_type END,\n            word_size_bytes=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_size_bytes END,\n            word_sha256=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_sha256 END,\n            word_generated_at=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_generated_at END,\n            word_error=CASE\n              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3\n              THEN NULL ELSE word_error END,\n            updated_at=CURRENT_TIMESTAMP\n        WHERE id=$1\n      `, [reportId, executiveSummary, reportDescription]);\n""",
-          )
-          replace_once(
-              workflow,
-              """  async addFollowUp(\n""",
-              """  async officialPdfContent(reportId: string): Promise<{ filePath: string; originalName: string; mimeType: string }> {\n    const [row] = await this.dataSource.query(`\n      SELECT\n        gedo_pdf_original_name AS \"originalName\",\n        gedo_pdf_stored_name AS \"storedName\",\n        gedo_pdf_mime_type AS \"mimeType\",\n        gedo_pdf_size_bytes::integer AS \"sizeBytes\",\n        gedo_pdf_sha256 AS sha256\n      FROM inspection_reports\n      WHERE id=$1\n    `, [reportId]) as Array<{\n      originalName: string | null;\n      storedName: string | null;\n      mimeType: string | null;\n      sizeBytes: number | null;\n      sha256: string | null;\n    }>;\n    if (!row) throw reportNotFound();\n    if (!row.originalName || !row.storedName || !row.sizeBytes || !row.sha256) {\n      throw new NotFoundException({\n        code: 'INSPECTION_REPORT_GEDO_PDF_NOT_AVAILABLE',\n        message: 'El PDF oficial de GEDO todavía no está disponible',\n      });\n    }\n    const filePath = resolve(this.root, row.storedName);\n    if (filePath === this.root || !filePath.startsWith(`${this.root}/`)) throw this.reportStorageError();\n    const fileStat = await stat(filePath).catch(() => null);\n    if (!fileStat?.isFile() || fileStat.size !== row.sizeBytes) throw this.reportStorageError();\n    const buffer = await readFile(filePath);\n    const sha256 = createHash('sha256').update(buffer).digest('hex');\n    if (sha256 !== row.sha256) throw this.reportStorageError();\n    return {\n      filePath,\n      originalName: row.originalName,\n      mimeType: row.mimeType ?? 'application/pdf',\n    };\n  }\n\n  async addFollowUp(\n""",
-          )
-          replace_once(
-              workflow,
-              """  private assertPdf(file: UploadedInspectionReportFile | undefined): void {\n""",
-              """  private reportStorageError(): InternalServerErrorException {\n    return new InternalServerErrorException({\n      code: 'INSPECTION_REPORT_GEDO_PDF_STORAGE_ERROR',\n      message: 'El PDF oficial de GEDO no está disponible o no supera la validación de integridad',\n    });\n  }\n\n  private assertPdf(file: UploadedInspectionReportFile | undefined): void {\n""",
-          )
-
-          word = 'api-v3/src/inspection-reports/inspection-report-word.service.ts'
-          replace_once(
-              word,
-              "const storedName = `${row.id}.docx`;",
-              "const storedName = `${row.id}-${built.sha256.slice(0, 16)}.docx`;",
-          )
-
-          compose = 'docker-compose.yml'
-          replace_once(
-              compose,
-              """      INSPECTION_REPORT_WORD_ROOT: /app/storage/asset-media/inspection-reports-word\n""",
-              """      INSPECTION_REPORT_UPLOAD_ROOT: /app/storage/asset-media/inspection-reports\n      INSPECTION_REPORT_WORD_ROOT: /app/storage/asset-media/inspection-reports-word\n""",
-          )
-
-          controller = 'api-v3/src/inspection-reports/inspection-reports.controller.ts'
-          replace_once(
-              controller,
-              """  @Patch(':id')\n""",
-              """  @Get(':id/gedo-pdf')\n  @RequirePermissions('inspection_reports.read')\n  async gedoPdfContent(\n    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,\n    @Res() response: Response,\n  ) {\n    const content = await this.workflow.officialPdfContent(id);\n    response.setHeader('Content-Type', content.mimeType);\n    response.setHeader('Content-Disposition', `attachment; filename=\"${content.originalName.replaceAll('\\\"', '')}\"`);\n    return response.sendFile(content.filePath);\n  }\n\n  @Patch(':id')\n""",
-          )
-
-          web_api = 'web-v2/src/lib/reportWorkflowApi.ts'
-          replace_once(
-              web_api,
-              """export function inspectionReportWordDownloadUrl(id: string) {\n  return `/api/v3/inspection-reports/${id}/word`;\n}\n""",
-              """export function inspectionReportWordDownloadUrl(id: string) {\n  return `/api/v3/inspection-reports/${id}/word`;\n}\n\nexport function inspectionReportGedoPdfDownloadUrl(id: string) {\n  return `/api/v3/inspection-reports/${id}/gedo-pdf`;\n}\n""",
-          )
-
-          page = 'web-v2/src/pages/ReportDetailPage.tsx'
-          replace_once(
-              page,
-              """  getInspectionReportF4,\n  inspectionReportWordDownloadUrl,\n""",
-              """  getInspectionReportF4,\n  inspectionReportGedoPdfDownloadUrl,\n  inspectionReportWordDownloadUrl,\n""",
-          )
-          replace_once(
-              page,
-              """          {report.gedoPdfSha256 && <div className=\"temporal-notice\"><Icon name=\"check\" /><p><strong>PDF GEDO fijado.</strong> SHA-256: <code>{report.gedoPdfSha256}</code></p></div>}\n""",
-              """          {report.gedoPdfOriginalName && <div className=\"form-actions\"><a className=\"button secondary\" href={inspectionReportGedoPdfDownloadUrl(report.id)}>Descargar PDF oficial</a></div>}\n          {report.gedoPdfSha256 && <div className=\"temporal-notice\"><Icon name=\"check\" /><p><strong>PDF GEDO fijado.</strong> SHA-256: <code>{report.gedoPdfSha256}</code></p></div>}\n""",
-          )
-
-          migration = Path('api-v3/src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts')
-          if migration.exists():
-              raise SystemExit(f'{migration}: file already exists')
-          migration.write_text("""import { MigrationInterface, QueryRunner } from 'typeorm';\n\nexport class F4AlignAssetVersionFunctionChange1790000700000 implements MigrationInterface {\n  name = 'F4AlignAssetVersionFunctionChange1790000700000';\n\n  public async up(queryRunner: QueryRunner): Promise<void> {\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      DROP CONSTRAINT IF EXISTS chk_asset_versions_change_type\n    `);\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      ADD CONSTRAINT chk_asset_versions_change_type CHECK (change_type IN (\n        'BASELINE', 'CREATED', 'UPDATED', 'CONTEXT_CHANGED', 'FUNCTION_CHANGED',\n        'STATUS_CHANGED', 'OPERATIONAL_STATUS_CHANGED', 'REGISTRY_UPDATED',\n        'GEOMETRY_UPDATED', 'GEOMETRY_REMOVED',\n        'MEDIA_UPLOADED', 'MEDIA_UPDATED', 'MEDIA_REMOVED',\n        'PROVENANCE_BASELINE', 'PROVENANCE_UPDATED', 'PROVENANCE_VERIFIED'\n      ))\n    `);\n  }\n\n  public async down(queryRunner: QueryRunner): Promise<void> {\n    await queryRunner.query(`\n      UPDATE asset_versions\n      SET change_type='UPDATED'\n      WHERE change_type='FUNCTION_CHANGED'\n    `);\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      DROP CONSTRAINT IF EXISTS chk_asset_versions_change_type\n    `);\n    await queryRunner.query(`\n      ALTER TABLE asset_versions\n      ADD CONSTRAINT chk_asset_versions_change_type CHECK (change_type IN (\n        'BASELINE', 'CREATED', 'UPDATED', 'CONTEXT_CHANGED',\n        'STATUS_CHANGED', 'OPERATIONAL_STATUS_CHANGED', 'REGISTRY_UPDATED',\n        'GEOMETRY_UPDATED', 'GEOMETRY_REMOVED',\n        'MEDIA_UPLOADED', 'MEDIA_UPDATED', 'MEDIA_REMOVED',\n        'PROVENANCE_BASELINE', 'PROVENANCE_UPDATED', 'PROVENANCE_VERIFIED'\n      ))\n    `);\n  }\n}\n""")
-
-          test_path = Path('api-v3/test/unit/f4-final-review-contract.test.ts')
-          if test_path.exists():
-              raise SystemExit(f'{test_path}: file already exists')
-          test_path.write_text("""import assert from 'node:assert/strict';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport test from 'node:test';\n\nconst root = process.cwd();\nconst read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');\n\nconst migration = read('src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts');\nconst workflow = read('src/inspection-reports/inspection-report-workflow.service.ts');\nconst word = read('src/inspection-reports/inspection-report-word.service.ts');\nconst controller = read('src/inspection-reports/inspection-reports.controller.ts');\nconst compose = read('../docker-compose.yml');\nconst webApi = read('../web-v2/src/lib/reportWorkflowApi.ts');\nconst reportPage = read('../web-v2/src/pages/ReportDetailPage.tsx');\n\ntest('F4 physically permits FUNCTION_CHANGED asset versions with a reversible downgrade', () => {\n  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));\n  const down = migration.slice(migration.indexOf('  public async down('));\n  assert.match(up, /FUNCTION_CHANGED/);\n  assert.match(down, /SET change_type='UPDATED'[\\s\\S]*WHERE change_type='FUNCTION_CHANGED'/);\n});\n\ntest('F4 GEDO and follow-up uploads stay under the persisted asset-media volume', () => {\n  assert.match(workflow, /\\?\\? '\\/app\\/storage\\/asset-media\\/inspection-reports'/);\n  assert.match(compose, /INSPECTION_REPORT_UPLOAD_ROOT: \\/app\\/storage\\/asset-media\\/inspection-reports/);\n  assert.match(compose, /dhv2_asset_media:\\/app\\/storage\\/asset-media/);\n});\n\ntest('F4 narrative edits invalidate the current generated Word without overwriting its historical file', () => {\n  const update = workflow.slice(workflow.indexOf('  async updateNarrative('), workflow.indexOf('  async officialize('));\n  assert.match(update, /word_status=CASE[\\s\\S]*THEN 'PENDING'/);\n  assert.match(update, /word_stored_name=CASE[\\s\\S]*THEN NULL/);\n  assert.match(update, /word_sha256=CASE[\\s\\S]*THEN NULL/);\n  assert.match(word, /built\\.sha256\\.slice\\(0, 16\\)/);\n});\n\ntest('F4 exposes the immutable official GEDO PDF through a protected integrity-checked download', () => {\n  assert.match(controller, /@Get\\(':id\\/gedo-pdf'\\)[\\s\\S]*@RequirePermissions\\('inspection_reports\\.read'\\)/);\n  assert.match(controller, /this\\.workflow\\.officialPdfContent\\(id\\)/);\n  assert.match(workflow, /async officialPdfContent\\(/);\n  assert.match(workflow, /fileStat\\.size !== row\\.sizeBytes/);\n  assert.match(workflow, /createHash\\('sha256'\\)\\.update\\(buffer\\)\\.digest\\('hex'\\)/);\n  assert.match(webApi, /inspectionReportGedoPdfDownloadUrl/);\n  assert.match(reportPage, /Descargar PDF oficial/);\n});\n""")
-
-          helper = Path('.github/workflows/f4-one-shot-final-review-fix.yml')
-          if not helper.exists():
-              raise SystemExit('one-shot helper workflow is missing')
-          helper.unlink()
-          PY
-
-          git diff --check
-
-      - name: Commit final audited corrections
-        run: |
-          set -Eeuo pipefail
-          if git diff --quiet; then
-            echo 'No changes produced; refusing silent success.'
-            exit 1
-          fi
-          git config user.name 'github-actions[bot]'
-          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
-          git add -A
-          git commit -m 'fix: close final F4 review gaps'
-          git push origin HEAD:feature/f4-backend-saneamiento-documental
diff --git a/api-v3/src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts b/api-v3/src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts
new file mode 100644
index 0000000..7ff4bfb
--- /dev/null
+++ b/api-v3/src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts
@@ -0,0 +1,44 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class F4AlignAssetVersionFunctionChange1790000700000 implements MigrationInterface {
+  name = 'F4AlignAssetVersionFunctionChange1790000700000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE asset_versions
+      DROP CONSTRAINT IF EXISTS chk_asset_versions_change_type
+    `);
+    await queryRunner.query(`
+      ALTER TABLE asset_versions
+      ADD CONSTRAINT chk_asset_versions_change_type CHECK (change_type IN (
+        'BASELINE', 'CREATED', 'UPDATED', 'CONTEXT_CHANGED', 'FUNCTION_CHANGED',
+        'STATUS_CHANGED', 'OPERATIONAL_STATUS_CHANGED', 'REGISTRY_UPDATED',
+        'GEOMETRY_UPDATED', 'GEOMETRY_REMOVED',
+        'MEDIA_UPLOADED', 'MEDIA_UPDATED', 'MEDIA_REMOVED',
+        'PROVENANCE_BASELINE', 'PROVENANCE_UPDATED', 'PROVENANCE_VERIFIED'
+      ))
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      UPDATE asset_versions
+      SET change_type='UPDATED'
+      WHERE change_type='FUNCTION_CHANGED'
+    `);
+    await queryRunner.query(`
+      ALTER TABLE asset_versions
+      DROP CONSTRAINT IF EXISTS chk_asset_versions_change_type
+    `);
+    await queryRunner.query(`
+      ALTER TABLE asset_versions
+      ADD CONSTRAINT chk_asset_versions_change_type CHECK (change_type IN (
+        'BASELINE', 'CREATED', 'UPDATED', 'CONTEXT_CHANGED',
+        'STATUS_CHANGED', 'OPERATIONAL_STATUS_CHANGED', 'REGISTRY_UPDATED',
+        'GEOMETRY_UPDATED', 'GEOMETRY_REMOVED',
+        'MEDIA_UPLOADED', 'MEDIA_UPDATED', 'MEDIA_REMOVED',
+        'PROVENANCE_BASELINE', 'PROVENANCE_UPDATED', 'PROVENANCE_VERIFIED'
+      ))
+    `);
+  }
+}
diff --git a/api-v3/src/inspection-reports/inspection-report-word.service.ts b/api-v3/src/inspection-reports/inspection-report-word.service.ts
index be0a9dd..fd1f559 100644
--- a/api-v3/src/inspection-reports/inspection-report-word.service.ts
+++ b/api-v3/src/inspection-reports/inspection-report-word.service.ts
@@ -58,7 +58,7 @@ export class InspectionReportWordService {
         reportDescription: row.reportDescription,
       });
       await mkdir(this.root, { recursive: true, mode: 0o700 });
-      const storedName = `${row.id}.docx`;
+      const storedName = `${row.id}-${built.sha256.slice(0, 16)}.docx`;
       const originalName = `${row.code}.docx`;
       const filePath = resolve(this.root, storedName);
       await writeFile(filePath, built.buffer, { mode: 0o600 });
diff --git a/api-v3/src/inspection-reports/inspection-report-workflow.service.ts b/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
index 1ef9d01..fbe9602 100644
--- a/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
+++ b/api-v3/src/inspection-reports/inspection-report-workflow.service.ts
@@ -1,10 +1,11 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
 import { isAbsolute, parse, resolve } from 'node:path';
 import {
   BadRequestException,
   ConflictException,
   Injectable,
+  InternalServerErrorException,
   NotFoundException,
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
@@ -58,7 +59,7 @@ export class InspectionReportWorkflowService {
     config: ConfigService,
   ) {
     const configured = config.get<string>('INSPECTION_REPORT_UPLOAD_ROOT')
-      ?? '/app/storage/inspection-reports';
+      ?? '/app/storage/asset-media/inspection-reports';
     if (!isAbsolute(configured)) throw new Error('INSPECTION_REPORT_UPLOAD_ROOT must be absolute');
     this.root = resolve(configured);
     if (this.root === parse(this.root).root) {
@@ -97,6 +98,30 @@ export class InspectionReportWorkflowService {
         UPDATE inspection_reports
         SET executive_summary=$2,
             report_description=$3,
+            word_status=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN 'PENDING' ELSE word_status END,
+            word_original_name=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN NULL ELSE word_original_name END,
+            word_stored_name=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN NULL ELSE word_stored_name END,
+            word_mime_type=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN NULL ELSE word_mime_type END,
+            word_size_bytes=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN NULL ELSE word_size_bytes END,
+            word_sha256=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN NULL ELSE word_sha256 END,
+            word_generated_at=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN NULL ELSE word_generated_at END,
+            word_error=CASE
+              WHEN executive_summary IS DISTINCT FROM $2 OR report_description IS DISTINCT FROM $3
+              THEN NULL ELSE word_error END,
             updated_at=CURRENT_TIMESTAMP
         WHERE id=$1
       `, [reportId, executiveSummary, reportDescription]);
@@ -195,6 +220,44 @@ export class InspectionReportWorkflowService {
     }
   }
 
+  async officialPdfContent(reportId: string): Promise<{ filePath: string; originalName: string; mimeType: string }> {
+    const [row] = await this.dataSource.query(`
+      SELECT
+        gedo_pdf_original_name AS "originalName",
+        gedo_pdf_stored_name AS "storedName",
+        gedo_pdf_mime_type AS "mimeType",
+        gedo_pdf_size_bytes::integer AS "sizeBytes",
+        gedo_pdf_sha256 AS sha256
+      FROM inspection_reports
+      WHERE id=$1
+    `, [reportId]) as Array<{
+      originalName: string | null;
+      storedName: string | null;
+      mimeType: string | null;
+      sizeBytes: number | null;
+      sha256: string | null;
+    }>;
+    if (!row) throw reportNotFound();
+    if (!row.originalName || !row.storedName || !row.sizeBytes || !row.sha256) {
+      throw new NotFoundException({
+        code: 'INSPECTION_REPORT_GEDO_PDF_NOT_AVAILABLE',
+        message: 'El PDF oficial de GEDO todavía no está disponible',
+      });
+    }
+    const filePath = resolve(this.root, row.storedName);
+    if (filePath === this.root || !filePath.startsWith(`${this.root}/`)) throw this.reportStorageError();
+    const fileStat = await stat(filePath).catch(() => null);
+    if (!fileStat?.isFile() || fileStat.size !== row.sizeBytes) throw this.reportStorageError();
+    const buffer = await readFile(filePath);
+    const sha256 = createHash('sha256').update(buffer).digest('hex');
+    if (sha256 !== row.sha256) throw this.reportStorageError();
+    return {
+      filePath,
+      originalName: row.originalName,
+      mimeType: row.mimeType ?? 'application/pdf',
+    };
+  }
+
   async addFollowUp(
     reportId: string,
     dto: CreateInspectionReportFollowUpDto,
@@ -291,6 +354,13 @@ export class InspectionReportWorkflowService {
     `, [reportId]);
   }
 
+  private reportStorageError(): InternalServerErrorException {
+    return new InternalServerErrorException({
+      code: 'INSPECTION_REPORT_GEDO_PDF_STORAGE_ERROR',
+      message: 'El PDF oficial de GEDO no está disponible o no supera la validación de integridad',
+    });
+  }
+
   private assertPdf(file: UploadedInspectionReportFile | undefined): void {
     if (!file?.buffer?.length) {
       throw new BadRequestException({
diff --git a/api-v3/src/inspection-reports/inspection-reports.controller.ts b/api-v3/src/inspection-reports/inspection-reports.controller.ts
index 3f44101..0dcdaf9 100644
--- a/api-v3/src/inspection-reports/inspection-reports.controller.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.controller.ts
@@ -68,6 +68,18 @@ export class InspectionReportsController {
     return response.sendFile(content.filePath);
   }
 
+  @Get(':id/gedo-pdf')
+  @RequirePermissions('inspection_reports.read')
+  async gedoPdfContent(
+    @Param('id', new ParseUUIDPipe({ version: '4' })) id: string,
+    @Res() response: Response,
+  ) {
+    const content = await this.workflow.officialPdfContent(id);
+    response.setHeader('Content-Type', content.mimeType);
+    response.setHeader('Content-Disposition', `attachment; filename="${content.originalName.replaceAll('\"', '')}"`);
+    return response.sendFile(content.filePath);
+  }
+
   @Patch(':id')
   @RequirePermissions('inspection_reports.generate')
   updateNarrative(
diff --git a/api-v3/test/unit/f4-final-review-contract.test.ts b/api-v3/test/unit/f4-final-review-contract.test.ts
new file mode 100644
index 0000000..46095c3
--- /dev/null
+++ b/api-v3/test/unit/f4-final-review-contract.test.ts
@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = process.cwd();
+const read = (relative: string) => fs.readFileSync(path.join(root, relative), 'utf8');
+
+const migration = read('src/database/migrations/1790000700000-f4-align-asset-version-function-change.ts');
+const workflow = read('src/inspection-reports/inspection-report-workflow.service.ts');
+const word = read('src/inspection-reports/inspection-report-word.service.ts');
+const controller = read('src/inspection-reports/inspection-reports.controller.ts');
+const compose = read('../docker-compose.yml');
+const webApi = read('../web-v2/src/lib/reportWorkflowApi.ts');
+const reportPage = read('../web-v2/src/pages/ReportDetailPage.tsx');
+
+test('F4 physically permits FUNCTION_CHANGED asset versions with a reversible downgrade', () => {
+  const up = migration.slice(migration.indexOf('  public async up('), migration.indexOf('  public async down('));
+  const down = migration.slice(migration.indexOf('  public async down('));
+  assert.match(up, /FUNCTION_CHANGED/);
+  assert.match(down, /SET change_type='UPDATED'[\s\S]*WHERE change_type='FUNCTION_CHANGED'/);
+});
+
+test('F4 GEDO and follow-up uploads stay under the persisted asset-media volume', () => {
+  assert.match(workflow, /\?\? '\/app\/storage\/asset-media\/inspection-reports'/);
+  assert.match(compose, /INSPECTION_REPORT_UPLOAD_ROOT: \/app\/storage\/asset-media\/inspection-reports/);
+  assert.match(compose, /dhv2_asset_media:\/app\/storage\/asset-media/);
+});
+
+test('F4 narrative edits invalidate the current generated Word without overwriting its historical file', () => {
+  const update = workflow.slice(workflow.indexOf('  async updateNarrative('), workflow.indexOf('  async officialize('));
+  assert.match(update, /word_status=CASE[\s\S]*THEN 'PENDING'/);
+  assert.match(update, /word_stored_name=CASE[\s\S]*THEN NULL/);
+  assert.match(update, /word_sha256=CASE[\s\S]*THEN NULL/);
+  assert.match(word, /built\.sha256\.slice\(0, 16\)/);
+});
+
+test('F4 exposes the immutable official GEDO PDF through a protected integrity-checked download', () => {
+  assert.match(controller, /@Get\(':id\/gedo-pdf'\)[\s\S]*@RequirePermissions\('inspection_reports\.read'\)/);
+  assert.match(controller, /this\.workflow\.officialPdfContent\(id\)/);
+  assert.match(workflow, /async officialPdfContent\(/);
+  assert.match(workflow, /fileStat\.size !== row\.sizeBytes/);
+  assert.match(workflow, /createHash\('sha256'\)\.update\(buffer\)\.digest\('hex'\)/);
+  assert.match(webApi, /inspectionReportGedoPdfDownloadUrl/);
+  assert.match(reportPage, /Descargar PDF oficial/);
+});
diff --git a/docker-compose.yml b/docker-compose.yml
index fb61c3c..0864444 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -50,6 +50,7 @@ services:
       ASSET_IMPORT_ROOT: /app/storage/asset-media/imports
       INSPECTION_EVIDENCE_ROOT: /app/storage/asset-media/inspection-findings
       INSPECTION_SIGNATURE_ROOT: /app/storage/asset-media/inspection-signatures
+      INSPECTION_REPORT_UPLOAD_ROOT: /app/storage/asset-media/inspection-reports
       INSPECTION_REPORT_WORD_ROOT: /app/storage/asset-media/inspection-reports-word
       INSPECTION_REPORT_REVISION_ROOT: /app/storage/asset-media/inspection-report-revisions
       INSPECTION_ACT_PDF_ROOT: /app/storage/asset-media/inspection-acts-pdf
diff --git a/web-v2/src/lib/reportWorkflowApi.ts b/web-v2/src/lib/reportWorkflowApi.ts
index b4cf29c..e73d361 100644
--- a/web-v2/src/lib/reportWorkflowApi.ts
+++ b/web-v2/src/lib/reportWorkflowApi.ts
@@ -201,3 +201,7 @@ export function addInspectionReportFollowUp(
 export function inspectionReportWordDownloadUrl(id: string) {
   return `/api/v3/inspection-reports/${id}/word`;
 }
+
+export function inspectionReportGedoPdfDownloadUrl(id: string) {
+  return `/api/v3/inspection-reports/${id}/gedo-pdf`;
+}
diff --git a/web-v2/src/pages/ReportDetailPage.tsx b/web-v2/src/pages/ReportDetailPage.tsx
index 107c8e1..5071f2e 100644
--- a/web-v2/src/pages/ReportDetailPage.tsx
+++ b/web-v2/src/pages/ReportDetailPage.tsx
@@ -9,6 +9,7 @@ import { formatDate } from '../lib/format';
 import {
   addInspectionReportFollowUp,
   getInspectionReportF4,
+  inspectionReportGedoPdfDownloadUrl,
   inspectionReportWordDownloadUrl,
   listInspectionReportFollowUps,
   officializeInspectionReport,
@@ -228,6 +229,7 @@ export function ReportDetailPage() {
             <div><small>PDF oficial</small><strong>{report.gedoPdfOriginalName ?? 'Registrado'}</strong></div>
             <div><small>Vencimiento del Acta</small><strong>{formatDate(report.act.deadlineAt)}</strong></div>
           </div>
+          {report.gedoPdfOriginalName && <div className="form-actions"><a className="button secondary" href={inspectionReportGedoPdfDownloadUrl(report.id)}>Descargar PDF oficial</a></div>}
           {report.gedoPdfSha256 && <div className="temporal-notice"><Icon name="check" /><p><strong>PDF GEDO fijado.</strong> SHA-256: <code>{report.gedoPdfSha256}</code></p></div>}
         </> : canManage && report.status === 'WORKING' ? <form className="form-section" onSubmit={officialize}>
           <div className="form-grid">

From 8584249eb2dba4f0fdd647c9bcb189ba3601727c Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 15:23:03 -0300
Subject: [PATCH 223/224] fix: sanitize GEDO download filename

---
 api-v3/src/inspection-reports/inspection-reports.controller.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api-v3/src/inspection-reports/inspection-reports.controller.ts b/api-v3/src/inspection-reports/inspection-reports.controller.ts
index 0dcdaf9..f194323 100644
--- a/api-v3/src/inspection-reports/inspection-reports.controller.ts
+++ b/api-v3/src/inspection-reports/inspection-reports.controller.ts
@@ -76,7 +76,7 @@ export class InspectionReportsController {
   ) {
     const content = await this.workflow.officialPdfContent(id);
     response.setHeader('Content-Type', content.mimeType);
-    response.setHeader('Content-Disposition', `attachment; filename="${content.originalName.replaceAll('\"', '')}"`);
+    response.setHeader('Content-Disposition', `attachment; filename="${content.originalName.replaceAll('"', '')}"`);
     return response.sendFile(content.filePath);
   }
 

From 9b86f49c9e851f5068d8585b667bb6bbe8dd3242 Mon Sep 17 00:00:00 2001
From: enlineawork <enlinea.work@gmail.com>
Date: Tue, 8 Sep 2026 15:27:33 -0300
Subject: [PATCH 224/224] ci: mount compose contract read-only in preflight

---
 .github/workflows/ci.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4a9081c..4f5dca7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -72,6 +72,7 @@ jobs:
           docker run --rm \
             -v "$PWD/api-v3/test:/app/test:ro" \
             -v "$PWD/api-v3/tsconfig.test.json:/app/tsconfig.test.json:ro" \
+            -v "$PWD/docker-compose.yml:/docker-compose.yml:ro" \
             -v "$PWD/web-v2:/web-v2:ro" \
             -v "$PWD/android-app:/android-app:ro" \
             "$image" npm test