Berakhirnya Status Badan Hukum PT (BERAKHIRNYA_STATUS_PT) Flow — Implementation Plan

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { SubmissionType } from "../../generated/prisma/enums";
import { processorKindForType } from "../../services/submission-dispatch";
import { APPROVED_TX_STATUS, BERAKHIRNYA_DONE_STATUS, PEMBUBARAN_AKSI, BERAKHIRNYA_AKSI, loadPembubaranRegistryState } from "../../services/company-lookup";
import { FLOW_REGISTRY } from "../registry";

/**
 * Task 1 — BERAKHIRNYA_STATUS_PT schema slice + the two compile-forced wiring
 * points (registry key + ProcessorKind case) + the empirical registry constants.
 * The registry entry is a TEMPORARY v1-fork stub until Task 6 registers the real
 * defineFlow config. ZERO other schema changes: the three DocumentTypes landed
 * with the registry slice; rupsKehadiranRegistry landed with Pembubaran; all
 * new-doc fields are ExtractedField rows (spec §6).
 */
describe("BERAKHIRNYA_STATUS_PT schema + compile-gate", () => {
  const ids: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: ids } } });
  });

  it("exposes the new enum value (distinct from the AKTA_BERAKHIRNYA label — exact equality everywhere)", () => {
    expect(SubmissionType.BERAKHIRNYA_STATUS_PT).toBe("BERAKHIRNYA_STATUS_PT");
    expect(SubmissionType.PEMBUBARAN_PT).toBe("PEMBUBARAN_PT"); // the PREREQUISITE flow — never aliased
  });

  it("persists a submission of the new type (reusing rupsKehadiranRegistry from the pembubaran slice)", async () => {
    const sub = await db.submission.create({
      data: {
        type: "BERAKHIRNYA_STATUS_PT", status: "CREATED",
        rupsKehadiranRegistry: [{ nama: "BUDI SANTOSO", persentase: 60, kehadiran: null }],
      },
    });
    ids.push(sub.id);
    const fresh = await db.submission.findUnique({ where: { id: sub.id } });
    expect(fresh?.type).toBe("BERAKHIRNYA_STATUS_PT");
    expect(fresh?.rupsKehadiranRegistry).toEqual([{ nama: "BUDI SANTOSO", persentase: 60, kehadiran: null }]);
  });

  it("routes the new type to the v2-generic ProcessorKind and a total registry", () => {
    expect(processorKindForType("BERAKHIRNYA_STATUS_PT")).toBe("v2-generic");
    expect(FLOW_REGISTRY.BERAKHIRNYA_STATUS_PT).toBeDefined();
  });

  it("exports the empirical registry constants (2026-07-03 erratum — supersede DISSOLVED_STATUS_TRANSAKSI=3)", () => {
    expect(APPROVED_TX_STATUS).toBe(1);
    expect(BERAKHIRNYA_DONE_STATUS).toBe(6);
    expect(PEMBUBARAN_AKSI).toBe(12);
    expect(BERAKHIRNYA_AKSI).toBe(36);
  });

  it("registry-state helper degrades to null when SABH is unavailable (test-setup blanks creds — never FAIL on outage)", async () => {
    expect(await loadPembubaranRegistryState(777, 2025)).toBeNull();
  });
});

  /// Berakhirnya Status Badan Hukum PT (SABH id_aksi_transaksi = 36, code 70 —
  /// SABH's code path is misleadingly named PerubahanStatus*): the TERMINAL PT
  /// transaction, ends legal personhood AFTER pembubaran (id_aksi 12) + liquidation
  /// complete — the deed ACCEPTS the likuidator's final accounting (contrast
  /// PEMBUBARAN_PT, which STARTS liquidation). 6-PDF statutory package (deed,
  /// risalah RUPS, surat permohonan, laporan akhir likuidasi, pengumuman Ps.149 +
  /// Ps.152). NO diff — per-document review vs the registry snapshot. FOURTH
  /// (final) engine:'v2-generic' FLOW_REGISTRY tenant. VERIFIKATOR-STAGED (submit
  /// creates a VerifikasiPerubahan row; voter roster = oldData.pemegang_saham).
  /// Prerequisite (approved pembubaran in SABH) is enforced at validation by
  /// BSBHP_REGISTRY_STATE reading a registry snapshot, NOT by the company lookup
  /// (which uses the default status filter — 2026-07-03 erratum).
  BERAKHIRNYA_STATUS_PT

/**
 * SABH tbl_transaksi_perseroan_<YYYY> registry facts for the Berakhirnya
 * prerequisite gate (spec §4.5/§4.6). Empirically verified read-only against live
 * AHU_BADAN_HUKUM on 2026-07-03 (controller-run, per-year shards):
 *   pembubaran rows (id_aksi_transaksi=12), 2025: status_transaksi 1→4866, 3→1, 0→1;
 *     2024: 1→3893, 0→8 → an APPROVED transaction row sits at status_transaksi=1
 *     regardless of aksi type (an approved pembubaran is 1, NOT 3).
 *   berakhirnya rows (id_aksi_transaksi=36), 2025: 6→121, 3→61, 7→43 → status 6 =
 *     COMPLETED berakhirnya (matches cross-validator.ts 6=berakhirnya); 3 there is an
 *     in-progress wizard state, NOT a dissolved-PT marker.
 * These SUPERSEDE the discovery-report claim "status_transaksi==3 = pembubaran
 * recorded" (docs/research/sabh-pt-untouched-flows-2026-07-01.md).
 */
export const APPROVED_TX_STATUS = 1;      // an approved transaction row (any aksi)
export const BERAKHIRNYA_DONE_STATUS = 6; // a COMPLETED berakhirnya row (id_aksi 36)
export const PEMBUBARAN_AKSI = 12;        // id_aksi_transaksi for a pembubaran filing
export const BERAKHIRNYA_AKSI = 36;       // id_aksi_transaksi for a berakhirnya filing

export interface PembubaranRegistryState {
  /** An APPROVED pembubaran row (id_aksi_transaksi=12, status_transaksi=1) exists. */
  approvedPembubaran: boolean;
  /** A COMPLETED berakhirnya row (id_aksi_transaksi=36, status_transaksi=6) exists. */
  completedBerakhirnya: boolean;
}

/**
 * Read-only, shard-aware scan of the PT's pembubaran/berakhirnya transaction rows —
 * the registry data BSBHP_REGISTRY_STATE gates on but the companyLookup payload does
 * NOT carry (the lookup row's status_transaksi is 1 for every approved row). Scans
 * per-year tbl_transaksi_perseroan_<YYYY>, newest shard first (company-lookup.ts
 * mechanics), keyed on id_perseroan. Returns null on SABH-unavailable / all-shard
 * error so the caller degrades to SKIPPED (partial-verification discipline — never
 * FAIL on an outage). The caller (buildBerakhirnyaContext) wraps this in withTimeout.
 */
export async function loadPembubaranRegistryState(
  idPerseroan: number,
  startYear: number,
): Promise<PembubaranRegistryState | null> {
  if (!isSabhAvailable()) return null;
  if (!Number.isFinite(idPerseroan)) return null;
  let approvedPembubaran = false;
  let completedBerakhirnya = false;
  let anyShardOk = false;
  for (let y = startYear; y >= startYear - MAX_YEAR_SCAN; y--) {
    try {
      const rows = await queryYearPartitioned(
        "tbl_transaksi_perseroan", y,
        `WHERE id_perseroan = ? AND ((id_aksi_transaksi = ? AND status_transaksi = ?) OR (id_aksi_transaksi = ? AND status_transaksi = ?))`,
        [idPerseroan, PEMBUBARAN_AKSI, APPROVED_TX_STATUS, BERAKHIRNYA_AKSI, BERAKHIRNYA_DONE_STATUS],
      );
      anyShardOk = true;
      for (const r of rows) {
        const aksi = parseIntOrNull(r.id_aksi_transaksi);
        const st = parseIntOrNull(r.status_transaksi);
        if (aksi === PEMBUBARAN_AKSI && st === APPROVED_TX_STATUS) approvedPembubaran = true;
        if (aksi === BERAKHIRNYA_AKSI && st === BERAKHIRNYA_DONE_STATUS) completedBerakhirnya = true;
      }
    } catch {
      continue; // per-shard: a missing/blipped shard must not fail the whole scan
    }
  }
  if (!anyShardOk) return null; // every shard errored → treat as outage → SKIPPED
  return { approvedPembubaran, completedBerakhirnya };
}

  // TEMPORARY v1-fork stub — satisfies Record totality until Task 6 registers the
  // real defineFlow(...) entry. processorKindForType already returns "v2-generic",
  // so a premature legacy dispatch throws LOUD (unreachable while the classifier
  // gate keeps the flow dark — BUILT_AKTA_TXN_TYPES flips in Task 7).
  BERAKHIRNYA_STATUS_PT: { engine: "v1-fork", type: "BERAKHIRNYA_STATUS_PT" },

    case "BERAKHIRNYA_STATUS_PT":
      // v2-generic: dispatch resolves FLOW_REGISTRY BEFORE this switch; the
      // switch's "v2-generic" case below is a deliberate unreachable-throw.
      return "v2-generic";

import { describe, it, expect, afterAll, afterEach } from "bun:test";
import { db } from "../../lib/db";
import {
  extractSuratPermohonan, runSuratPermohonanPass, PERMOHONAN_EXTRACTED_FIELD_KEYS,
} from "../surat-permohonan-extract";

const RAW =
  "SURAT PERMOHONAN\nNomor: 012/BSBH/VI/2026\nJakarta, 15 Juni 2026\n" +
  "Perihal: Permohonan pemberitahuan berakhirnya status badan hukum\n" +
  "PT KARYA USAI SUDAH berkedudukan di Jakarta Selatan,\n" +
  "sehubungan dengan telah selesainya proses likuidasi.";

function mockLlm(content: object | null, status = 200) {
  const orig = globalThis.fetch;
  globalThis.fetch = (async () =>
    new Response(
      JSON.stringify({ choices: [{ message: { content: content ? JSON.stringify(content) : "" } }] }),
      { status },
    )) as typeof fetch;
  return () => { globalThis.fetch = orig; };
}

const LLM_FULL = {
  nomor_surat_permohonan: "012/BSBH/VI/2026",
  tanggal_surat_permohonan: "15 Juni 2026",
  permohonan_nama_perseroan: "PT KARYA USAI SUDAH",
};

describe("extractSuratPermohonan (grounded 3B — filing-letter shape)", () => {
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });

  it("grounds all three values verbatim (word-form date stored RAW — apostille convention)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const r = await extractSuratPermohonan(RAW);
      expect(r.nomor_surat_permohonan).toBe("012/BSBH/VI/2026");
      expect(r.tanggal_surat_permohonan).toBe("15 Juni 2026"); // raw word form, parsed at rule time
      expect(r.permohonan_nama_perseroan).toBe("PT KARYA USAI SUDAH");
    } finally { restore(); }
  });

  it("rejects hallucinated values → null", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ ...LLM_FULL, nomor_surat_permohonan: "999/PALSU/2026", permohonan_nama_perseroan: "PT HALUSINASI" });
    try {
      const r = await extractSuratPermohonan(RAW);
      expect(r.nomor_surat_permohonan).toBeNull();
      expect(r.permohonan_nama_perseroan).toBeNull();
      expect(r.tanggal_surat_permohonan).toBe("15 Juni 2026"); // grounded value survives
    } finally { restore(); }
  });

  it("outage / empty text → all-null; never throws", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(null, 500);
    try {
      const r = await extractSuratPermohonan(RAW);
      expect(Object.values(r).every((v) => v === null)).toBe(true);
      const empty = await extractSuratPermohonan("");
      expect(Object.values(empty).every((v) => v === null)).toBe(true);
    } finally { restore(); }
  });
});

describe("runSuratPermohonanPass persistence (3 ExtractedField rows, atomic, idempotent-once)", () => {
  const docIds: string[] = [];
  afterAll(async () => { await db.document.deleteMany({ where: { id: { in: docIds } } }); });

  async function seedDoc() {
    const doc = await db.document.create({
      data: {
        filename: "sp.pdf", originalName: "sp.pdf", fileSize: 0, filePath: "/tmp/sp.pdf",
        documentType: "SURAT_PERMOHONAN", status: "VERIFICATION_READY", rawText: RAW,
      },
    });
    docIds.push(doc.id);
    return doc.id;
  }

  it("persists ALL 3 canonical rows in one shot (0.75 grounded tier; null → FLAGGED)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ ...LLM_FULL, permohonan_nama_perseroan: null });
    try {
      const documentId = await seedDoc();
      await runSuratPermohonanPass({ submissionId: "s", documentId, rawText: RAW });
      const rows = await db.extractedField.findMany({ where: { documentId } });
      expect(rows.length).toBe(PERMOHONAN_EXTRACTED_FIELD_KEYS.length);
      const nomor = rows.find((r) => r.fieldKey === "nomor_surat_permohonan");
      expect(nomor?.value).toBe("012/BSBH/VI/2026");
      expect(nomor?.confidence).toBe(0.75); // "please review" tier — never auto-LOCK
      expect(nomor?.status).toBe("EDITABLE");
      const nama = rows.find((r) => r.fieldKey === "permohonan_nama_perseroan");
      expect(nama?.value).toBeNull();
      expect(nama?.status).toBe("FLAGGED");
    } finally { restore(); }
  });

  it("is idempotent-once: NEVER clobbers existing rows (operator edit survives resume)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const documentId = await seedDoc();
      await db.extractedField.create({
        data: { documentId, fieldKey: "nomor_surat_permohonan", value: "EDIT OPERATOR", confidence: 1, status: "MANUAL" },
      });
      await runSuratPermohonanPass({ submissionId: "s", documentId, rawText: RAW });
      const rows = await db.extractedField.findMany({ where: { documentId } });
      expect(rows.length).toBe(1); // any-key → skip-ALL (sound: the write is atomic)
      expect(rows[0]?.value).toBe("EDIT OPERATOR");
    } finally { restore(); }
  });

  it("skips loudly (no rows) on empty rawText — manual entry path, never an ERROR", async () => {
    const documentId = await seedDoc();
    await runSuratPermohonanPass({ submissionId: "s", documentId, rawText: "" });
    expect(await db.extractedField.findMany({ where: { documentId } })).toEqual([]);
  });
});

import { describe, it, expect, afterAll, afterEach } from "bun:test";
import { db } from "../../lib/db";
import {
  extractLaporanLikuidasi, runLaporanLikuidasiPass, LAPORAN_LIKUIDASI_EXTRACTED_FIELD_KEYS,
} from "../laporan-likuidasi-extract";

const RAW =
  "LAPORAN AKHIR LIKUIDASI\nNomor: 03/LAL/VI/2026\nJakarta, 10 Juni 2026\n" +
  "Likuidator PT KARYA USAI SUDAH (dalam likuidasi), BUDI HARTONO, S.H.,\n" +
  "dengan ini menyampaikan pertanggungjawaban likuidator.\n" +
  "Sisa kekayaan hasil likuidasi: Rp 12.500.000\n" +
  "telah dibagikan kepada para pemegang saham.";

function mockLlm(content: object | null, status = 200) {
  const orig = globalThis.fetch;
  globalThis.fetch = (async () =>
    new Response(
      JSON.stringify({ choices: [{ message: { content: content ? JSON.stringify(content) : "" } }] }),
      { status },
    )) as typeof fetch;
  return () => { globalThis.fetch = orig; };
}

const LLM_FULL = {
  nama_likuidator: "BUDI HARTONO, S.H.",
  nomor_laporan_likuidasi: "03/LAL/VI/2026",
  tanggal_laporan_likuidasi: "10 Juni 2026",
  sisa_kekayaan: "Rp 12.500.000",
  laporan_nama_perseroan: "PT KARYA USAI SUDAH",
};

describe("extractLaporanLikuidasi (grounded 3B — LAPORAN shape ONLY, C2)", () => {
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });

  it("grounds all five values verbatim (incl. sisa_kekayaan amount + word-form date)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const r = await extractLaporanLikuidasi(RAW);
      expect(r.nama_likuidator).toBe("BUDI HARTONO, S.H.");
      expect(r.nomor_laporan_likuidasi).toBe("03/LAL/VI/2026");
      expect(r.tanggal_laporan_likuidasi).toBe("10 Juni 2026");
      expect(r.sisa_kekayaan).toBe("Rp 12.500.000");
      expect(r.laporan_nama_perseroan).toBe("PT KARYA USAI SUDAH");
    } finally { restore(); }
  });

  it("grounds 'nihil' sisa kekayaan verbatim", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const nihilRaw = RAW.replace("Rp 12.500.000", "nihil");
    const restore = mockLlm({ ...LLM_FULL, sisa_kekayaan: "nihil" });
    try {
      const r = await extractLaporanLikuidasi(nihilRaw);
      expect(r.sisa_kekayaan).toBe("nihil");
    } finally { restore(); }
  });

  it("rejects hallucinated values → null", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ ...LLM_FULL, nama_likuidator: "SINTA HALUSINASI", sisa_kekayaan: "Rp 999.999.999" });
    try {
      const r = await extractLaporanLikuidasi(RAW);
      expect(r.nama_likuidator).toBeNull();
      expect(r.sisa_kekayaan).toBeNull();
    } finally { restore(); }
  });

  it("outage / empty text → all-null; never throws", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(null, 500);
    try {
      const r = await extractLaporanLikuidasi(RAW);
      expect(Object.values(r).every((v) => v === null)).toBe(true);
      const empty = await extractLaporanLikuidasi("");
      expect(Object.values(empty).every((v) => v === null)).toBe(true);
    } finally { restore(); }
  });
});

describe("runLaporanLikuidasiPass persistence (5 ExtractedField rows, atomic, idempotent-once)", () => {
  const docIds: string[] = [];
  afterAll(async () => { await db.document.deleteMany({ where: { id: { in: docIds } } }); });

  async function seedDoc() {
    const doc = await db.document.create({
      data: {
        filename: "lal.pdf", originalName: "lal.pdf", fileSize: 0, filePath: "/tmp/lal.pdf",
        documentType: "LAPORAN_LIKUIDASI", status: "VERIFICATION_READY", rawText: RAW,
      },
    });
    docIds.push(doc.id);
    return doc.id;
  }

  it("persists ALL 5 canonical rows in one shot", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const documentId = await seedDoc();
      await runLaporanLikuidasiPass({ submissionId: "s", documentId, rawText: RAW });
      const rows = await db.extractedField.findMany({ where: { documentId } });
      expect(rows.length).toBe(LAPORAN_LIKUIDASI_EXTRACTED_FIELD_KEYS.length);
      expect(rows.find((r) => r.fieldKey === "sisa_kekayaan")?.value).toBe("Rp 12.500.000");
      expect(rows.find((r) => r.fieldKey === "nama_likuidator")?.confidence).toBe(0.75);
    } finally { restore(); }
  });

  it("is idempotent-once (operator edit survives resume)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(LLM_FULL);
    try {
      const documentId = await seedDoc();
      await db.extractedField.create({
        data: { documentId, fieldKey: "nama_likuidator", value: "EDIT OPERATOR", confidence: 1, status: "MANUAL" },
      });
      await runLaporanLikuidasiPass({ submissionId: "s", documentId, rawText: RAW });
      const rows = await db.extractedField.findMany({ where: { documentId } });
      expect(rows.length).toBe(1);
      expect(rows[0]?.value).toBe("EDIT OPERATOR");
    } finally { restore(); }
  });

  it("skips loudly on empty rawText", async () => {
    const documentId = await seedDoc();
    await runLaporanLikuidasiPass({ submissionId: "s", documentId, rawText: "" });
    expect(await db.extractedField.findMany({ where: { documentId } })).toEqual([]);
  });
});

/**
 * Focused, grounded SURAT_PERMOHONAN extractor — BERAKHIRNYA_STATUS_PT's filing
 * letter (SABH PDF #3; spec §4.4). DISTINCT from SURAT_PERMOHONAN_KORPORASI (the
 * Perbaikan-korporasi letter) — schema doc-comment + exact-equality mapping keep
 * them apart. Shape mirrors the SHARED clipping extractor (bukti-pengumuman-
 * extract.ts): ONE 3B guided-JSON call (CLEANUP_LLM, temperature 0), every value
 * grounded VERBATIM against rawText (hallucination → null, never an ERROR).
 * Dates stored RAW (word form allowed — parsed at rule time via parseFlexibleDate;
 * apostille date convention). permohonan_nama_perseroan carries the letter's PT
 * name for BSBHP_NAMA_PT_DOCS (spec §4.5 NAMA_PT_CONSISTENCY extension).
 * Persistence: 3 ExtractedField rows (spec §6 — no satellite table), grounded
 * 0.75 "please review" tier, ONE atomic createMany, IDEMPOTENT-ONCE.
 */
import { db } from "../lib/db";

export interface SuratPermohonanFields {
  nomor_surat_permohonan: string | null;
  tanggal_surat_permohonan: string | null;
  permohonan_nama_perseroan: string | null;
}

export const PERMOHONAN_EXTRACTED_FIELD_KEYS = [
  "nomor_surat_permohonan", "tanggal_surat_permohonan", "permohonan_nama_perseroan",
] as const;

const NONE: SuratPermohonanFields = {
  nomor_surat_permohonan: null, tanggal_surat_permohonan: null, permohonan_nama_perseroan: null,
};

export async function extractSuratPermohonan(rawText: string): Promise<SuratPermohonanFields> {
  const url = process.env.CLEANUP_LLM_URL || "";
  const model = process.env.CLEANUP_LLM_MODEL || "cleanup-3b";
  if (!url) return { ...NONE };
  if (!rawText.trim()) {
    console.warn("[surat-permohonan] rawText empty — extraction skipped (GPU-OCR path?)");
    return { ...NONE };
  }
  const system =
    "From an Indonesian surat permohonan pemberitahuan berakhirnya status badan hukum perseroan " +
    "(the filing letter to the Minister after a PT's liquidation completes), extract: " +
    "nomor_surat_permohonan (the letter number as printed, e.g. '012/BSBH/VI/2026'), " +
    "tanggal_surat_permohonan (the letter date exactly as written — word form allowed), " +
    "permohonan_nama_perseroan (the PT name the letter concerns, including the 'PT' prefix if printed). " +
    "Copy VERBATIM from the text; if absent, return null. Never invent. " +
    "Return ONLY JSON {nomor_surat_permohonan, tanggal_surat_permohonan, permohonan_nama_perseroan}.";
  try {
    const res = await fetch(`${url}/chat/completions`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        model, temperature: 0,
        messages: [
          { role: "system", content: system },
          { role: "user", content: rawText.slice(0, 12000) },
        ],
        guided_json: {
          type: "object",
          properties: Object.fromEntries(PERMOHONAN_EXTRACTED_FIELD_KEYS.map((k) => [k, { type: ["string", "null"] }])),
          required: [...PERMOHONAN_EXTRACTED_FIELD_KEYS],
          additionalProperties: false,
        },
      }),
      signal: AbortSignal.timeout(parseInt(process.env.CLEANUP_LLM_TIMEOUT_MS || "30000", 10)),
    });
    if (!res.ok) return { ...NONE };
    const json = (await res.json()) as { choices?: { message?: { content?: string } }[] };
    const m = (json.choices?.[0]?.message?.content ?? "").match(/\{[\s\S]*\}/);
    if (!m) return { ...NONE };
    const parsed = JSON.parse(m[0]) as Partial<Record<keyof SuratPermohonanFields, string | null>>;
    const norm = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
    const hay = norm(rawText);
    const ground = (v: string | null | undefined): string | null => {
      const s = v ? String(v).trim() : "";
      return s && hay.includes(norm(s)) ? s : null;
    };
    return {
      nomor_surat_permohonan: ground(parsed.nomor_surat_permohonan),
      tanggal_surat_permohonan: ground(parsed.tanggal_surat_permohonan),
      permohonan_nama_perseroan: ground(parsed.permohonan_nama_perseroan),
    };
  } catch (err) {
    console.warn("[surat-permohonan] 3B extraction failed:", err);
    return { ...NONE };
  }
}

/** The 'surat-permohonan' focused-pass body (invoked by flow-engine focusedPasses). */
export async function runSuratPermohonanPass(args: { submissionId: string; documentId: string; rawText: string }): Promise<void> {
  const { documentId, rawText } = args;
  if (!rawText.trim()) {
    console.warn(`[surat-permohonan] no rawText for doc ${documentId} — focused pass skipped (manual entry via PUT /permohonan)`);
    return;
  }
  const existing = await db.extractedField.findMany({
    where: { documentId, fieldKey: { in: [...PERMOHONAN_EXTRACTED_FIELD_KEYS] } },
    select: { id: true },
  });
  if (existing.length > 0) return; // idempotent-once — operator edits survive engine resume
  const r = await extractSuratPermohonan(rawText);
  await db.extractedField.createMany({
    data: PERMOHONAN_EXTRACTED_FIELD_KEYS.map((fieldKey) => {
      const value = r[fieldKey];
      return {
        documentId, fieldKey, value,
        confidence: value ? 0.75 : 0, // grounded-3B "please review" tier — never auto-LOCK
        status: value ? "EDITABLE" : "FLAGGED",
      };
    }),
  });
}

/**
 * Focused, grounded LAPORAN_LIKUIDASI extractor — the likuidator's final
 * accounting (laporan akhir / pertanggungjawaban; SABH PDF #4; spec §4.4).
 * LAPORAN SHAPE ONLY: the penunjukan letter is Pembubaran's DISTINCT
 * SURAT_LIKUIDATOR DocumentType (surat-likuidator-extract.ts) — the doc-set
 * predicate keys on that distinction (C2), so this extractor must never swallow
 * it. sisa_kekayaan is the SABH-typed remaining-assets field — deeds/letters
 * state it in prose (an Rp amount or the word "nihil"); grounded verbatim.
 * laporan_nama_perseroan carries the letter's PT name for BSBHP_NAMA_PT_DOCS.
 * Persistence: 5 ExtractedField rows, 0.75 tier, ONE atomic createMany,
 * IDEMPOTENT-ONCE. Dates stored RAW (apostille date convention).
 */
import { db } from "../lib/db";

export interface LaporanLikuidasiFields {
  nama_likuidator: string | null;
  nomor_laporan_likuidasi: string | null;
  tanggal_laporan_likuidasi: string | null;
  sisa_kekayaan: string | null;
  laporan_nama_perseroan: string | null;
}

export const LAPORAN_LIKUIDASI_EXTRACTED_FIELD_KEYS = [
  "nama_likuidator", "nomor_laporan_likuidasi", "tanggal_laporan_likuidasi",
  "sisa_kekayaan", "laporan_nama_perseroan",
] as const;

const NONE: LaporanLikuidasiFields = {
  nama_likuidator: null, nomor_laporan_likuidasi: null, tanggal_laporan_likuidasi: null,
  sisa_kekayaan: null, laporan_nama_perseroan: null,
};

export async function extractLaporanLikuidasi(rawText: string): Promise<LaporanLikuidasiFields> {
  const url = process.env.CLEANUP_LLM_URL || "";
  const model = process.env.CLEANUP_LLM_MODEL || "cleanup-3b";
  if (!url) return { ...NONE };
  if (!rawText.trim()) {
    console.warn("[laporan-likuidasi] rawText empty — extraction skipped (GPU-OCR path?)");
    return { ...NONE };
  }
  const system =
    "From an Indonesian laporan akhir likuidasi / pertanggungjawaban likuidator " +
    "(the liquidator's FINAL accounting for a dissolved PT — NOT the appointment letter), extract: " +
    "nama_likuidator (the liquidator's full name incl. titles), " +
    "nomor_laporan_likuidasi (the report/letter number as printed), " +
    "tanggal_laporan_likuidasi (the report date exactly as written — word form allowed), " +
    "sisa_kekayaan (the remaining-assets statement exactly as printed — an amount like 'Rp 12.500.000' or the word 'nihil'), " +
    "laporan_nama_perseroan (the PT name the report concerns). " +
    "Copy VERBATIM from the text; if absent, return null. Never invent. " +
    "Return ONLY JSON {nama_likuidator, nomor_laporan_likuidasi, tanggal_laporan_likuidasi, sisa_kekayaan, laporan_nama_perseroan}.";
  try {
    const res = await fetch(`${url}/chat/completions`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        model, temperature: 0,
        messages: [
          { role: "system", content: system },
          { role: "user", content: rawText.slice(0, 12000) },
        ],
        guided_json: {
          type: "object",
          properties: Object.fromEntries(LAPORAN_LIKUIDASI_EXTRACTED_FIELD_KEYS.map((k) => [k, { type: ["string", "null"] }])),
          required: [...LAPORAN_LIKUIDASI_EXTRACTED_FIELD_KEYS],
          additionalProperties: false,
        },
      }),
      signal: AbortSignal.timeout(parseInt(process.env.CLEANUP_LLM_TIMEOUT_MS || "30000", 10)),
    });
    if (!res.ok) return { ...NONE };
    const json = (await res.json()) as { choices?: { message?: { content?: string } }[] };
    const m = (json.choices?.[0]?.message?.content ?? "").match(/\{[\s\S]*\}/);
    if (!m) return { ...NONE };
    const parsed = JSON.parse(m[0]) as Partial<Record<keyof LaporanLikuidasiFields, string | null>>;
    const norm = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
    const hay = norm(rawText);
    const ground = (v: string | null | undefined): string | null => {
      const s = v ? String(v).trim() : "";
      return s && hay.includes(norm(s)) ? s : null;
    };
    return {
      nama_likuidator: ground(parsed.nama_likuidator),
      nomor_laporan_likuidasi: ground(parsed.nomor_laporan_likuidasi),
      tanggal_laporan_likuidasi: ground(parsed.tanggal_laporan_likuidasi),
      sisa_kekayaan: ground(parsed.sisa_kekayaan),
      laporan_nama_perseroan: ground(parsed.laporan_nama_perseroan),
    };
  } catch (err) {
    console.warn("[laporan-likuidasi] 3B extraction failed:", err);
    return { ...NONE };
  }
}

/** The 'laporan-likuidasi' focused-pass body (invoked by flow-engine focusedPasses). */
export async function runLaporanLikuidasiPass(args: { submissionId: string; documentId: string; rawText: string }): Promise<void> {
  const { documentId, rawText } = args;
  if (!rawText.trim()) {
    console.warn(`[laporan-likuidasi] no rawText for doc ${documentId} — focused pass skipped (manual entry via PUT /laporan-likuidasi)`);
    return;
  }
  const existing = await db.extractedField.findMany({
    where: { documentId, fieldKey: { in: [...LAPORAN_LIKUIDASI_EXTRACTED_FIELD_KEYS] } },
    select: { id: true },
  });
  if (existing.length > 0) return; // idempotent-once — operator edits survive engine resume
  const r = await extractLaporanLikuidasi(rawText);
  await db.extractedField.createMany({
    data: LAPORAN_LIKUIDASI_EXTRACTED_FIELD_KEYS.map((fieldKey) => {
      const value = r[fieldKey];
      return {
        documentId, fieldKey, value,
        confidence: value ? 0.75 : 0,
        status: value ? "EDITABLE" : "FLAGGED",
      };
    }),
  });
}

  "surat-permohonan": async (args) => {
    const { runSuratPermohonanPass } = await import("../services/surat-permohonan-extract");
    await runSuratPermohonanPass(args);
  },
  "laporan-likuidasi": async (args) => {
    const { runLaporanLikuidasiPass } = await import("../services/laporan-likuidasi-extract");
    await runLaporanLikuidasiPass(args);
  },

    // 6l. SURAT_PERMOHONAN (berakhirnya filing letter) — OCR-ONLY. The grounded
    // extraction runs as the flow-engine 'surat-permohonan' focusedPasses pass,
    // NOT here. Without this case the letter falls through to the generic Akta
    // handler and burns an akta-VLM extraction on a 1-page letter.
    if (doc.documentType === "SURAT_PERMOHONAN") {
      const layoutProvider = await getLayoutProvider("paddleocr");
      const ocr = await layoutProvider.extractTextWithWords(fileBuffer, { unwarp: false, orient: false });
      await db.document.update({
        where: { id: documentId },
        data: { rawText: ocr.rawText ?? "", pageCount: ocr.pageCount ?? 1, status: "VERIFICATION_READY" },
      });
      return;
    }

    // 6m. LAPORAN_LIKUIDASI (laporan akhir likuidasi, Berakhirnya) — OCR-ONLY.
    // The grounded 5-field extraction runs as the flow-engine 'laporan-likuidasi'
    // focusedPasses pass, NOT here.
    if (doc.documentType === "LAPORAN_LIKUIDASI") {
      const layoutProvider = await getLayoutProvider("paddleocr");
      const ocr = await layoutProvider.extractTextWithWords(fileBuffer, { unwarp: false, orient: false });
      await db.document.update({
        where: { id: documentId },
        data: { rawText: ocr.rawText ?? "", pageCount: ocr.pageCount ?? 1, status: "VERIFICATION_READY" },
      });
      return;
    }

import { describe, it, expect, afterAll, afterEach } from "bun:test";
import { db } from "../../lib/db";
import {
  extractPembubaranRef, runBerakhirnyaDeedPasses, PEMBUBARAN_REF_FIELD_KEYS,
} from "../akta-pembubaran-ref-extract";

// The deed's OWN nomor is 7; the recited pembubaran deed is Nomor 5 — the pass
// must return the RECITED one (prompt is explicit; both are grounded, so the
// grounding tier cannot disambiguate — the prompt + WARNING-tier rule keep it safe).
const RAW =
  "AKTA BERAKHIRNYA STATUS BADAN HUKUM\nPT KARYA USAI SUDAH (dalam likuidasi)\nNomor 7, tanggal 20 Juni 2026\n" +
  "bahwa berdasarkan Akta Pembubaran Nomor 5 tanggal 30 April 2026 yang dibuat di hadapan\n" +
  "notaris RATNA SARI, S.H., Perseroan telah dibubarkan dan likuidator telah ditunjuk;\n" +
  "bahwa RUPS tanggal 18 Juni 2026 telah menerima pertanggungjawaban likuidator.";

function mockLlm(content: object | null, status = 200) {
  const orig = globalThis.fetch;
  globalThis.fetch = (async () =>
    new Response(
      JSON.stringify({ choices: [{ message: { content: content ? JSON.stringify(content) : "" } }] }),
      { status },
    )) as typeof fetch;
  return () => { globalThis.fetch = orig; };
}

describe("extractPembubaranRef (grounded 3B — the premisse's dissolution-deed recital)", () => {
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });

  it("grounds the recited nomor + tanggal verbatim", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nomor_akta_pembubaran: "5", tanggal_akta_pembubaran: "30 April 2026" });
    try {
      const r = await extractPembubaranRef(RAW);
      expect(r.nomor_akta_pembubaran).toBe("5");
      expect(r.tanggal_akta_pembubaran).toBe("30 April 2026");
    } finally { restore(); }
  });

  it("rejects hallucinated values → null; outage → all-null", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    let restore = mockLlm({ nomor_akta_pembubaran: "99", tanggal_akta_pembubaran: "1 Januari 2020" });
    try {
      const r = await extractPembubaranRef(RAW);
      expect(r.nomor_akta_pembubaran).toBeNull();
      expect(r.tanggal_akta_pembubaran).toBeNull();
    } finally { restore(); }
    restore = mockLlm(null, 500);
    try {
      const out = await extractPembubaranRef(RAW);
      expect(out.nomor_akta_pembubaran).toBeNull();
    } finally { restore(); }
  });
});

describe("runBerakhirnyaDeedPasses persistence (2 ExtractedField rows on the DEED, atomic, idempotent-once)", () => {
  const docIds: string[] = [];
  afterAll(async () => { await db.document.deleteMany({ where: { id: { in: docIds } } }); });

  async function seedAkta() {
    const doc = await db.document.create({
      data: {
        filename: "akta.pdf", originalName: "akta.pdf", fileSize: 0, filePath: "/tmp/akta.pdf",
        documentType: "AKTA", status: "VERIFICATION_READY", rawText: RAW,
      },
    });
    docIds.push(doc.id);
    return doc.id;
  }

  it("writes both canonical rows (0.75 / FLAGGED-null)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nomor_akta_pembubaran: "5", tanggal_akta_pembubaran: null });
    try {
      const aktaDocumentId = await seedAkta();
      await runBerakhirnyaDeedPasses({ submissionId: "s", aktaDocumentId, rawText: RAW });
      const rows = await db.extractedField.findMany({
        where: { documentId: aktaDocumentId, fieldKey: { in: [...PEMBUBARAN_REF_FIELD_KEYS] } },
      });
      expect(rows.length).toBe(2);
      expect(rows.find((r) => r.fieldKey === "nomor_akta_pembubaran")?.value).toBe("5");
      expect(rows.find((r) => r.fieldKey === "nomor_akta_pembubaran")?.confidence).toBe(0.75);
      expect(rows.find((r) => r.fieldKey === "tanggal_akta_pembubaran")?.status).toBe("FLAGGED");
    } finally { restore(); }
  });

  it("is idempotent-once: a resume/re-extract never clobbers operator edits", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nomor_akta_pembubaran: "5", tanggal_akta_pembubaran: "30 April 2026" });
    try {
      const aktaDocumentId = await seedAkta();
      await db.extractedField.create({
        data: { documentId: aktaDocumentId, fieldKey: "nomor_akta_pembubaran", value: "EDIT", confidence: 1, status: "MANUAL" },
      });
      await runBerakhirnyaDeedPasses({ submissionId: "s", aktaDocumentId, rawText: RAW });
      const rows = await db.extractedField.findMany({
        where: { documentId: aktaDocumentId, fieldKey: { in: [...PEMBUBARAN_REF_FIELD_KEYS] } },
      });
      expect(rows.length).toBe(1);
      expect(rows[0]?.value).toBe("EDIT");
    } finally { restore(); }
  });

  it("skips loudly on empty rawText (GPU-akta path) — never a processing failure", async () => {
    const aktaDocumentId = await seedAkta();
    await runBerakhirnyaDeedPasses({ submissionId: "s", aktaDocumentId, rawText: "" });
    expect(await db.extractedField.findMany({
      where: { documentId: aktaDocumentId, fieldKey: { in: [...PEMBUBARAN_REF_FIELD_KEYS] } },
    })).toEqual([]);
  });
});