Peleburan PT (Konsolidasi, PELEBURAN_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 { FLOW_REGISTRY } from "../registry";

/**
 * Task 1 — PELEBURAN_PT schema slice + the two compile-forced wiring points
 * (registry key + ProcessorKind case). The registry entry is a TEMPORARY
 * v1-fork stub until Task 7 registers the real defineFlow config.
 */
describe("PELEBURAN_PT schema + compile-gate", () => {
  const ids: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: ids } } });
  });

  it("exposes the new enum value", () => {
    expect(SubmissionType.PELEBURAN_PT).toBe("PELEBURAN_PT");
  });

  it("persists PeleburanSourcePt rows keyed by (submissionId, ordinal)", async () => {
    const sub = await db.submission.create({ data: { type: "PELEBURAN_PT", status: "CREATED" } });
    ids.push(sub.id);
    const row = await db.peleburanSourcePt.create({
      data: {
        submissionId: sub.id, ordinal: 0,
        namaPerseroan: "PT SUMBER SATU", nomorSk: "AHU-0001.AH.01.01.TAHUN 2020", tanggalRups: "10 Maret 2026",
      },
    });
    expect(row.resolutionStatus).toBe("PENDING");
    expect(row.companyLookupResult).toBeNull();
    expect(row.oldData).toBeNull();
    expect(row.blokirState).toBeNull();
    // @@unique([submissionId, ordinal])
    await expect(
      db.peleburanSourcePt.create({ data: { submissionId: sub.id, ordinal: 0, namaPerseroan: "PT DUP" } }),
    ).rejects.toThrow();
    // cascade delete rides the submission
    await db.submission.delete({ where: { id: sub.id } });
    ids.splice(ids.indexOf(sub.id), 1);
    expect(await db.peleburanSourcePt.findMany({ where: { submissionId: sub.id } })).toEqual([]);
  });

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

  /// Peleburan PT (Konsolidasi, SABH id_aksi_transaksi = 35, UUPT Ps.122): two or
  /// more registered PTs consolidate into a BRAND-NEW PT; the sources' legal
  /// personhood ends by operation of law. NEW-ENTITY transaction: the deed carries
  /// a pendirian-grade payload; the N source PTs live on PeleburanSourcePt rows.
  /// SECOND engine:'v2-generic' FLOW_REGISTRY tenant. VERIFIKATOR-STAGED (submit
  /// creates a VerifikasiPerubahan row — contrast terminal LAPORAN_RUPS_TAHUNAN).
  PELEBURAN_PT

/// One row per source PT of a PELEBURAN_PT submission (spec §4.4/§6). Carries the
/// extracted deed reference, the SABH lookup result, the operator/auto selection,
/// the OldData snapshot and the blokir state. Multi-source generalization of the
/// single-company quintet on Submission (which stays null for this type).
model PeleburanSourcePt {
  id                     String     @id @default(cuid())
  submissionId           String
  submission             Submission @relation(fields: [submissionId], references: [id], onDelete: Cascade)
  ordinal                Int
  /// extracted (grounded) or manually entered
  namaPerseroan          String
  nomorSk                String?
  /// per-source RUPS approval date (word-form as recited in the deed)
  tanggalRups            String?
  /// LookupResponse (company-lookup.ts)
  companyLookupResult    Json?
  selectedNomorTransaksi String?
  selectedTahun          Int?
  /// OldData snapshot (company-lookup.ts)
  oldData                Json?
  /// PerseroanBlokirState (company-lookup.ts)
  blokirState            Json?
  /// PENDING | AUTO_SELECTED | AWAITING_SELECTION | MANUAL
  resolutionStatus       String     @default("PENDING")
  createdAt              DateTime   @default(now())
  updatedAt              DateTime   @updatedAt

  @@unique([submissionId, ordinal])
  @@index([submissionId])
}

  peleburanSources PeleburanSourcePt[]

  // TEMPORARY v1-fork stub — satisfies Record totality until Task 7 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 8).
  PELEBURAN_PT: { engine: "v1-fork", type: "PELEBURAN_PT" },

    case "PELEBURAN_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 { extractBuktiPengumuman, runBuktiPengumumanPass } from "../bukti-pengumuman-extract";
import { extractKoranFields } from "../akta-koran-extract";

const RAW =
  "HARIAN KOMPAS\nJakarta, 12 Mei 2026\nPENGUMUMAN\nRINGKASAN RANCANGAN PELEBURAN\n" +
  "PT SUMBER SATU dan PT SUMBER DUA akan meleburkan diri ke dalam PT BARU HASIL LEBUR";

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("extractKoranFields (parameterized deed-inline refactor)", () => {
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });

  it("sends the caller's docContext in the prompt and grounds values", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    let sentBody = "";
    const orig = globalThis.fetch;
    globalThis.fetch = (async (_u: unknown, init?: RequestInit) => {
      sentBody = String(init?.body ?? "");
      return new Response(JSON.stringify({ choices: [{ message: { content: JSON.stringify({ tanggal_koran: "12 Mei 2026", nama_koran: "HARIAN HALUSINASI" }) } }] }), { status: 200 });
    }) as typeof fetch;
    try {
      const r = await extractKoranFields(RAW, { docContext: "akta peleburan (konsolidasi)" });
      expect(sentBody).toContain("akta peleburan (konsolidasi)");
      expect(r.tanggal_koran).toBe("12 Mei 2026");
      expect(r.nama_koran).toBeNull(); // not in rawText → grounded away
    } finally { globalThis.fetch = orig; }
  });
});

describe("extractBuktiPengumuman (grounded 3B clipping extractor)", () => {
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });

  it("grounds every value; hallucinated koran name → null; nomor stays null when absent", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nama_koran: "HARIAN KOMPAS", tanggal_pengumuman: "12 Mei 2026", nomor_pengumuman: "No. 999/XY" });
    try {
      const r = await extractBuktiPengumuman(RAW);
      expect(r.nama_koran).toBe("HARIAN KOMPAS");
      expect(r.tanggal_pengumuman).toBe("12 Mei 2026");
      expect(r.nomor_pengumuman).toBeNull(); // not in rawText → grounded away
    } finally { restore(); }
  });

  it("returns all-null on empty rawText and never throws on LLM outage", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(null, 500);
    try {
      expect(await extractBuktiPengumuman("")).toEqual({ nama_koran: null, tanggal_pengumuman: null, nomor_pengumuman: null });
      expect(await extractBuktiPengumuman(RAW)).toEqual({ nama_koran: null, tanggal_pengumuman: null, nomor_pengumuman: null });
    } finally { restore(); }
  });
});

describe("runBuktiPengumumanPass persistence (ExtractedField rows — spec §6, no satellite)", () => {
  const docIds: string[] = [];
  afterAll(async () => { await db.document.deleteMany({ where: { id: { in: docIds } } }); });

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

  it("persists the three canonical ExtractedField rows (grounded 0.75 tier; null → FLAGGED)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nama_koran: "HARIAN KOMPAS", tanggal_pengumuman: "12 Mei 2026", nomor_pengumuman: null });
    try {
      const documentId = await seedDoc();
      await runBuktiPengumumanPass({ submissionId: "s", documentId, rawText: RAW });
      const nama = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId, fieldKey: "nama_koran" } } });
      expect(nama?.value).toBe("HARIAN KOMPAS");
      expect(nama?.status).toBe("EDITABLE");
      expect(nama?.confidence).toBe(0.75);
      const nomor = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId, fieldKey: "nomor_pengumuman" } } });
      expect(nomor?.value).toBeNull();
      expect(nomor?.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({ nama_koran: "HARIAN KOMPAS", tanggal_pengumuman: "12 Mei 2026", nomor_pengumuman: null });
    try {
      const documentId = await seedDoc();
      await db.extractedField.create({ data: { documentId, fieldKey: "nama_koran", value: "EDIT OPERATOR", confidence: 1, status: "MANUAL" } });
      await runBuktiPengumumanPass({ submissionId: "s", documentId, rawText: RAW });
      const nama = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId, fieldKey: "nama_koran" } } });
      expect(nama?.value).toBe("EDIT OPERATOR");
    } finally { restore(); }
  });

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

/**
 * Focused, grounded newspaper-announcement (koran) extraction (mirrors apostille
 * single-field recovery). ONE parameterized implementation serving every deed
 * that recites the pengumuman inline — akuisisi (existing call sites in
 * document-processor.ts:416/472, via the extractKoranViaFocusedLlm delegate),
 * peleburan, and later pembubaran. Never broaden this prompt per-flow — pass a
 * docContext instead (3B brittleness, memory reference_apostille_extraction_llm).
 */
export async function extractKoranFields(
  rawText: string,
  opts: { docContext: string },
): Promise<{ tanggal_koran: string | null; nama_koran: string | null }> {
  const url = process.env.CLEANUP_LLM_URL || "";
  const model = process.env.CLEANUP_LLM_MODEL || "cleanup-3b";
  const NONE = { tanggal_koran: null, nama_koran: null };
  if (!url) return NONE;
  if (!rawText.trim()) {
    // URL is configured but there's no OCR text to ground against — this is the
    // GPU-OCR path where the server returns no rawText. Surface it so the gap is
    // visible in logs instead of silently returning nulls.
    console.warn("[akta-koran] rawText empty — koran extraction skipped (GPU-OCR path?)");
    return NONE;
  }
  const system =
    `From an Indonesian ${opts.docContext}, extract the newspaper announcement (pengumuman surat kabar): ` +
    "tanggal_koran (publication date) and nama_koran (newspaper/gazette name, e.g. 'Berita Negara'). " +
    "Copy VERBATIM from the text; if absent, return null. Never invent. Return ONLY JSON {tanggal_koran, nama_koran}.";
  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: {
            tanggal_koran: { type: ["string", "null"] },
            nama_koran: { type: ["string", "null"] },
          },
          required: ["tanggal_koran", "nama_koran"],
          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 { tanggal_koran?: string | null; nama_koran?: 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 { tanggal_koran: ground(parsed.tanggal_koran), nama_koran: ground(parsed.nama_koran) };
  } catch {
    return NONE;
  }
}

/** AKUISISI delegate — keeps document-processor.ts call sites byte-identical (v1 fork untouched). */
export async function extractKoranViaFocusedLlm(
  rawText: string,
): Promise<{ tanggal_koran: string | null; nama_koran: string | null }> {
  return extractKoranFields(rawText, { docContext: "akta pengambilalihan (akuisisi)" });
}

/**
 * SHARED BUKTI_PENGUMUMAN clipping extractor (first consumer: PELEBURAN_PT;
 * reused verbatim by PEMBUBARAN_PT and BERAKHIRNYA_STATUS_PT). Canonical
 * nullable field keys: nama_koran / tanggal_pengumuman / nomor_pengumuman
 * (nomor stays null for peleburan — only Berakhirnya consumes it).
 * Grounded 3B (CLEANUP_LLM), temperature 0, guided-JSON, verbatim-substring
 * grounding. Persists ExtractedField rows (spec §6 — no satellite table),
 * IDEMPOTENT-ONCE: an engine resume must never clobber operator edits.
 */
import { db } from "../lib/db";

export interface BuktiPengumumanFields {
  nama_koran: string | null;
  tanggal_pengumuman: string | null;
  nomor_pengumuman: string | null;
}
const NONE: BuktiPengumumanFields = { nama_koran: null, tanggal_pengumuman: null, nomor_pengumuman: null };

export async function extractBuktiPengumuman(rawText: string): Promise<BuktiPengumumanFields> {
  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("[bukti-pengumuman] rawText empty — clipping extraction skipped (GPU-OCR path?)");
    return { ...NONE };
  }
  const system =
    "From an Indonesian newspaper clipping (bukti pengumuman koran — Pasal 127(2) UUPT announcement), extract: " +
    "nama_koran (the newspaper masthead, e.g. 'Harian Kompas'), tanggal_pengumuman (the publication date as printed), " +
    "nomor_pengumuman (the announcement/edition number, if printed). " +
    "Copy VERBATIM from the text; if absent, return null. Never invent. " +
    "Return ONLY JSON {nama_koran, tanggal_pengumuman, nomor_pengumuman}.";
  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: {
            nama_koran: { type: ["string", "null"] },
            tanggal_pengumuman: { type: ["string", "null"] },
            nomor_pengumuman: { type: ["string", "null"] },
          },
          required: ["nama_koran", "tanggal_pengumuman", "nomor_pengumuman"],
          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 BuktiPengumumanFields, 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_koran: ground(parsed.nama_koran),
      tanggal_pengumuman: ground(parsed.tanggal_pengumuman),
      nomor_pengumuman: ground(parsed.nomor_pengumuman),
    };
  } catch (err) {
    console.warn("[bukti-pengumuman] 3B extraction failed:", err);
    return { ...NONE };
  }
}

/** The 'bukti-pengumuman' focused-pass body (invoked by flow-engine focusedPasses). */
export async function runBuktiPengumumanPass(args: { submissionId: string; documentId: string; rawText: string }): Promise<void> {
  const { documentId, rawText } = args;
  if (!rawText.trim()) {
    console.warn(`[bukti-pengumuman] no rawText for doc ${documentId} — focused pass skipped`);
    return;
  }
  const KEYS = ["nama_koran", "tanggal_pengumuman", "nomor_pengumuman"] as const;
  const existing = await db.extractedField.findMany({ where: { documentId, fieldKey: { in: [...KEYS] } } });
  if (existing.length > 0) return; // idempotent-once — operator edits survive engine resume
  const r = await extractBuktiPengumuman(rawText);
  for (const fieldKey of KEYS) {
    const value = r[fieldKey];
    await db.extractedField.create({
      data: {
        documentId, fieldKey, value,
        confidence: value ? 0.75 : 0, // grounded-3B "please review" tier — never auto-LOCK territory
        status: value ? "EDITABLE" : "FLAGGED",
      },
    });
  }
}

  "bukti-pengumuman": async (args) => {
    const { runBuktiPengumumanPass } = await import("../services/bukti-pengumuman-extract");
    await runBuktiPengumumanPass(args);
  },

    // 6j. BUKTI_PENGUMUMAN (Pasal 127(2) newspaper clipping) — OCR-ONLY. The
    // grounded clipping extraction runs as the flow-engine 'bukti-pengumuman'
    // focusedPasses pass, NOT here. Without this case the clipping falls through
    // to the generic Akta handler and burns an akta-VLM extraction on newsprint.
    if (doc.documentType === "BUKTI_PENGUMUMAN") {
      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 { extractPeleburanSourcesViaLlm, runPeleburanDeedPasses } from "../akta-peleburan-sources-extract";

const RAW =
  "AKTA PELEBURAN\nPERSEROAN TERBATAS PT BARU HASIL LEBUR\n" +
  "PT SUMBER SATU, berkedudukan di Jakarta, SK AHU-0001.AH.01.01.TAHUN 2020, RUPS tanggal 10 Maret 2026\n" +
  "PT SUMBER DUA, berkedudukan di Bandung, SK AHU-0002.AH.01.01.TAHUN 2019, RUPS tanggal 11 Maret 2026\n" +
  "sepakat meleburkan diri dengan mendirikan PT BARU HASIL LEBUR. Pengumuman surat kabar Harian Kompas tanggal 1 Februari 2026";

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("extractPeleburanSourcesViaLlm (grounded 35B)", () => {
  const origEnv = process.env.AKTA_TXN_CLASSIFIER_URL;
  afterEach(() => { process.env.AKTA_TXN_CLASSIFIER_URL = origEnv; });

  it("keeps verbatim sources, drops a fabricated one, nulls an ungrounded SK", async () => {
    process.env.AKTA_TXN_CLASSIFIER_URL = "http://mock";
    const restore = mockLlm({
      sources: [
        { nama_perseroan: "PT SUMBER SATU", nomor_sk: "AHU-0001.AH.01.01.TAHUN 2020", tanggal_rups: "10 Maret 2026" },
        { nama_perseroan: "PT SUMBER DUA", nomor_sk: "AHU-9999.FAKE", tanggal_rups: "11 Maret 2026" },
        { nama_perseroan: "PT HALUSINASI ABADI", nomor_sk: null, tanggal_rups: null },
      ],
    });
    try {
      const r = await extractPeleburanSourcesViaLlm(RAW);
      expect(r).toHaveLength(2); // fabricated source DROPPED
      expect(r[0]).toEqual({ nama_perseroan: "PT SUMBER SATU", nomor_sk: "AHU-0001.AH.01.01.TAHUN 2020", tanggal_rups: "10 Maret 2026" });
      expect(r[1]!.nomor_sk).toBeNull(); // ungrounded SK nulled, source kept
      expect(r[1]!.tanggal_rups).toBe("11 Maret 2026");
    } finally { restore(); }
  });

  it("returns [] on empty rawText, LLM outage, or unset URL — never throws", async () => {
    process.env.AKTA_TXN_CLASSIFIER_URL = "http://mock";
    const restore = mockLlm(null, 500);
    try {
      expect(await extractPeleburanSourcesViaLlm("")).toEqual([]);
      expect(await extractPeleburanSourcesViaLlm(RAW)).toEqual([]);
    } finally { restore(); }
    process.env.AKTA_TXN_CLASSIFIER_URL = "";
    expect(await extractPeleburanSourcesViaLlm(RAW)).toEqual([]);
  });
});

describe("runPeleburanDeedPasses (source rows + inline koran)", () => {
  const ids: string[] = [];
  const docIds: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: ids } } });
    await db.document.deleteMany({ where: { id: { in: docIds } } });
  });

  async function seed() {
    const akta = await db.document.create({
      data: { filename: "a.pdf", originalName: "a.pdf", fileSize: 0, filePath: "/tmp/a.pdf", documentType: "AKTA", status: "VERIFICATION_READY", rawText: RAW },
    });
    docIds.push(akta.id);
    const sub = await db.submission.create({ data: { type: "PELEBURAN_PT", status: "EXTRACTING" } });
    ids.push(sub.id);
    return { subId: sub.id, aktaId: akta.id };
  }

  it("persists grounded source rows (ordinal order) + inline koran ExtractedFields on the akta", async () => {
    process.env.AKTA_TXN_CLASSIFIER_URL = "http://mock";
    process.env.CLEANUP_LLM_URL = "http://mock";
    // ONE mock serves both calls: guided_json keys distinguish them by response shape —
    // return a superset object; each extractor picks its own keys and grounds them.
    const restore = mockLlm({
      sources: [
        { nama_perseroan: "PT SUMBER SATU", nomor_sk: "AHU-0001.AH.01.01.TAHUN 2020", tanggal_rups: "10 Maret 2026" },
        { nama_perseroan: "PT SUMBER DUA", nomor_sk: null, tanggal_rups: "11 Maret 2026" },
      ],
      tanggal_koran: "1 Februari 2026",
      nama_koran: "Harian Kompas",
    });
    try {
      const { subId, aktaId } = await seed();
      await runPeleburanDeedPasses({ submissionId: subId, aktaDocumentId: aktaId, rawText: RAW });
      const rows = await db.peleburanSourcePt.findMany({ where: { submissionId: subId }, orderBy: { ordinal: "asc" } });
      expect(rows).toHaveLength(2);
      expect(rows[0]!.namaPerseroan).toBe("PT SUMBER SATU");
      expect(rows[0]!.resolutionStatus).toBe("PENDING");
      expect(rows[1]!.tanggalRups).toBe("11 Maret 2026");
      const koran = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId: aktaId, fieldKey: "tanggal_pengumuman" } } });
      expect(koran?.value).toBe("1 Februari 2026");
      const nama = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId: aktaId, fieldKey: "nama_koran" } } });
      expect(nama?.value).toBe("Harian Kompas");
    } finally { restore(); }
  });

  it("is idempotent-once: existing rows (e.g. manual adds/selections) are never recreated", async () => {
    process.env.AKTA_TXN_CLASSIFIER_URL = "http://mock";
    const restore = mockLlm({ sources: [{ nama_perseroan: "PT SUMBER SATU", nomor_sk: null, tanggal_rups: null }] });
    try {
      const { subId, aktaId } = await seed();
      await db.peleburanSourcePt.create({
        data: { submissionId: subId, ordinal: 0, namaPerseroan: "PT MANUAL OPERATOR", resolutionStatus: "MANUAL" },
      });
      await runPeleburanDeedPasses({ submissionId: subId, aktaDocumentId: aktaId, rawText: RAW });
      const rows = await db.peleburanSourcePt.findMany({ where: { submissionId: subId } });
      expect(rows).toHaveLength(1);
      expect(rows[0]!.namaPerseroan).toBe("PT MANUAL OPERATOR");
    } finally { restore(); }
  });

  it("degrades gracefully on empty rawText: zero rows, no throw (manual entry in the panel)", async () => {
    const { subId, aktaId } = await seed();
    await runPeleburanDeedPasses({ submissionId: subId, aktaDocumentId: aktaId, rawText: "" });
    expect(await db.peleburanSourcePt.findMany({ where: { submissionId: subId } })).toEqual([]);
  });
});

/**
 * Focused pass A — source-PT references of an AKTA PELEBURAN (spec §4.3).
 * A grounded guided-JSON call on the 35B endpoint (AKTA_TXN_CLASSIFIER_URL —
 * Qwen3.6-35B-A3B-FP8 @8001): list-of-objects extraction is exactly where the
 * 3B is brittle (memory reference_apostille_extraction_llm), and this is one
 * call per submission. Grounding: a source whose nama_perseroan is not a
 * verbatim substring of the (normalized) rawText is DROPPED; nomor_sk and
 * tanggal_rups are individually grounded-or-null. Fabricated sources are thus
 * structurally unlikely; extraction MISSES are covered by manual add in the
 * PeleburanSourcesPanel.
 */
import { db } from "../lib/db";
import { extractKoranFields } from "./akta-koran-extract";

export interface PeleburanSourceRef {
  nama_perseroan: string;
  nomor_sk: string | null;
  tanggal_rups: string | null;
}

export async function extractPeleburanSourcesViaLlm(rawText: string): Promise<PeleburanSourceRef[]> {
  const url = process.env.AKTA_TXN_CLASSIFIER_URL || "";
  const model = process.env.AKTA_TXN_CLASSIFIER_MODEL || "Qwen/Qwen3.6-35B-A3B-FP8";
  const timeoutMs = parseInt(process.env.AKTA_TXN_CLASSIFIER_TIMEOUT_MS || "30000", 10);
  if (!url) return [];
  if (!rawText.trim()) {
    console.warn("[peleburan-sources] rawText empty — source extraction skipped (GPU-OCR path?)");
    return [];
  }
  const system =
    "From an Indonesian akta peleburan (konsolidasi) deed, extract the SOURCE companies — the existing PTs that " +
    "meleburkan diri (merge themselves) into the new company. They are recited in the premisse/komparisi with their " +
    "SK Menkumham numbers and RUPS approval dates. For each source return: nama_perseroan (full PT name), " +
    "nomor_sk (its SK Menkumham number, e.g. 'AHU-0001.AH.01.01.TAHUN 2020', null if absent), " +
    "tanggal_rups (the date of that PT's RUPS approving the peleburan, as written, null if absent). " +
    "Do NOT include the NEW company being founded. Copy VERBATIM; never invent. " +
    'Return ONLY JSON {"sources": [{nama_perseroan, nomor_sk, tanggal_rups}]}.';
  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, 16000) },
        ],
        guided_json: {
          type: "object",
          properties: {
            sources: {
              type: "array",
              items: {
                type: "object",
                properties: {
                  nama_perseroan: { type: "string" },
                  nomor_sk: { type: ["string", "null"] },
                  tanggal_rups: { type: ["string", "null"] },
                },
                required: ["nama_perseroan", "nomor_sk", "tanggal_rups"],
                additionalProperties: false,
              },
            },
          },
          required: ["sources"],
          additionalProperties: false,
        },
      }),
      signal: AbortSignal.timeout(timeoutMs),
    });
    if (!res.ok) {
      console.error(`[peleburan-sources] LLM responded ${res.status}`);
      return [];
    }
    const json = (await res.json()) as { choices?: { message?: { content?: string } }[] };
    const m = (json.choices?.[0]?.message?.content ?? "").match(/\{[\s\S]*\}/);
    if (!m) return [];
    const parsed = JSON.parse(m[0]) as { sources?: Array<Partial<PeleburanSourceRef>> };
    if (!Array.isArray(parsed.sources)) return [];
    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;
    };
    const out: PeleburanSourceRef[] = [];
    for (const src of parsed.sources) {
      const nama = ground(src.nama_perseroan);
      if (!nama) continue; // fabricated / ungroundable source — DROP
      out.push({ nama_perseroan: nama, nomor_sk: ground(src.nomor_sk), tanggal_rups: ground(src.tanggal_rups) });
    }
    return out;
  } catch (err) {
    console.error("[peleburan-sources] 35B extraction failed:", err);
    return [];
  }
}

/**
 * The flow's hooks.afterAktaExtraction body (spec §4.3 passes A + B-inline).
 * IDEMPOTENT-ONCE on both halves: existing PeleburanSourcePt rows (earlier run
 * OR manual adds/selections) and existing koran ExtractedFields are never
 * recreated/clobbered on engine resume. Log-and-continue is enforced by the
 * engine (processor.ts afterAktaExtraction try/catch) — this body may throw
 * only DB errors, never LLM ones.
 */
export async function runPeleburanDeedPasses(a: { submissionId: string; aktaDocumentId: string; rawText: string }): Promise<void> {
  const { submissionId, aktaDocumentId, rawText } = a;
  if (!rawText.trim()) {
    console.warn(`[peleburan-sources] no rawText for akta ${aktaDocumentId} — deed passes skipped (manual entry in the panel)`);
    return;
  }

  // Pass A — source refs → PeleburanSourcePt rows (idempotent-once).
  const existingRows = await db.peleburanSourcePt.count({ where: { submissionId } });
  if (existingRows === 0) {
    const refs = await extractPeleburanSourcesViaLlm(rawText);
    for (let i = 0; i < refs.length; i++) {
      const r = refs[i]!;
      await db.peleburanSourcePt.create({
        data: {
          submissionId, ordinal: i,
          namaPerseroan: r.nama_perseroan, nomorSk: r.nomor_sk, tanggalRups: r.tanggal_rups,
        },
      });
    }
  }

  // Pass B (deed-INLINE koran fallback) — canonical keys nama_koran / tanggal_pengumuman
  // on the AKTA document. The BUKTI_PENGUMUMAN clipping (focusedPasses) is the better
  // source when uploaded; context resolution prefers the clipping (peleburan-context.ts).
  const existingKoran = await db.extractedField.findMany({
    where: { documentId: aktaDocumentId, fieldKey: { in: ["nama_koran", "tanggal_pengumuman"] } },
  });
  if (existingKoran.length === 0) {
    const koran = await extractKoranFields(rawText, { docContext: "akta peleburan (konsolidasi)" });
    const pairs: Array<[string, string | null]> = [
      ["nama_koran", koran.nama_koran],
      ["tanggal_pengumuman", koran.tanggal_koran],
    ];
    for (const [fieldKey, value] of pairs) {
      await db.extractedField.create({
        data: { documentId: aktaDocumentId, fieldKey, value, confidence: value ? 0.75 : 0, status: value ? "EDITABLE" : "FLAGGED" },
      });
    }
  }
}

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { resolvePeleburanSources, hasUnresolvedSources, selectSourceRow } from "../../services/peleburan-sources";
import { runFlow } from "../processor";
import { defineFlow, type FlowConfig } from "../types";

const HIGH = (nama: string, nomor: string) => ({
  confidence: "high" as const, nomor_transaksi: nomor, nama_perseroan: nama,
  kedudukan: "JAKARTA", nomor_sk: "AHU-0001", npwp_perseroan: null, tahun_transaksi: 2020,
});
const OLD_DATA = {
  perseroan: { nama: "PT SUMBER SATU", kedudukan: null, alamat: null, status_perseroan: "AKTIF", jenis_perseroan: null, jangka_waktu: null, npwp: null, telepon: null, email: null, id_perseroan: 77, status_transaksi: 1, id_notaris: null },
  modal: { modal_dasar: null, modal_ditempatkan: null, modal_disetor: null },
  kbli: [], direksi: [], komisaris: [], pemegang_saham: [],
};

function deps(over: Partial<Record<"matches" | "blocked", unknown>> = {}) {
  return {
    sabhAvailable: () => true,
    lookupCompany: async () => ({ matches: (over.matches as never) ?? [HIGH("PT SUMBER SATU", "TX-1")] }),
    loadOldData: async () => OLD_DATA as never,
    loadPerseroanBlokirState: async () => ({ blocked: (over.blocked as boolean) ?? false, reason: null }),
  };
}

describe("resolvePeleburanSources (per-row loop over the single-company primitives)", () => {
  const ids: string[] = [];
  afterAll(async () => { await db.submission.deleteMany({ where: { id: { in: ids } } }); });

  async function seed(rows: Array<{ ordinal: number; nama: string; status?: string }>) {
    const sub = await db.submission.create({ data: { type: "PELEBURAN_PT", status: "EXTRACTING" } });
    ids.push(sub.id);
    for (const r of rows) {
      await db.peleburanSourcePt.create({
        data: { submissionId: sub.id, ordinal: r.ordinal, namaPerseroan: r.nama, resolutionStatus: r.status ?? "PENDING" },
      });
    }
    return sub.id;
  }

  it("exactly-one-high → AUTO_SELECTED with oldData + blokirState persisted", async () => {
    const subId = await seed([{ ordinal: 0, nama: "PT SUMBER SATU" }]);
    await resolvePeleburanSources(subId, deps());
    const row = await db.peleburanSourcePt.findUnique({ where: { submissionId_ordinal: { submissionId: subId, ordinal: 0 } } });
    expect(row?.resolutionStatus).toBe("AUTO_SELECTED");
    expect(row?.selectedNomorTransaksi).toBe("TX-1");
    expect(row?.selectedTahun).toBe(2020);
    expect((row?.oldData as { perseroan: { id_perseroan: number } }).perseroan.id_perseroan).toBe(77);
    expect((row?.blokirState as { blocked: boolean }).blocked).toBe(false);
    expect(await hasUnresolvedSources(subId)).toBe(false);
  });

  it("ambiguous/empty matches → AWAITING_SELECTION with the lookup result persisted", async () => {
    const subId = await seed([{ ordinal: 0, nama: "PT SUMBER DUA" }]);
    await resolvePeleburanSources(subId, deps({ matches: [HIGH("A", "TX-1"), HIGH("B", "TX-2")] }));
    const row = await db.peleburanSourcePt.findUnique({ where: { submissionId_ordinal: { submissionId: subId, ordinal: 0 } } });
    expect(row?.resolutionStatus).toBe("AWAITING_SELECTION");
    expect((row?.companyLookupResult as { matches: unknown[] }).matches).toHaveLength(2);
    expect(await hasUnresolvedSources(subId)).toBe(true);
  });

  it("SABH unavailable → MANUAL (typed-in identity; source rules will SKIP)", async () => {
    const subId = await seed([{ ordinal: 0, nama: "PT SUMBER TIGA" }]);
    await resolvePeleburanSources(subId, { ...deps(), sabhAvailable: () => false });
    const row = await db.peleburanSourcePt.findUnique({ where: { submissionId_ordinal: { submissionId: subId, ordinal: 0 } } });
    expect(row?.resolutionStatus).toBe("MANUAL");
    expect(row?.oldData).toBeNull();
  });

  it("only PENDING rows are touched (idempotent for selected/manual rows)", async () => {
    const subId = await seed([
      { ordinal: 0, nama: "PT A", status: "MANUAL" },
      { ordinal: 1, nama: "PT B" },
    ]);
    await resolvePeleburanSources(subId, deps());
    const rows = await db.peleburanSourcePt.findMany({ where: { submissionId: subId }, orderBy: { ordinal: "asc" } });
    expect(rows[0]!.resolutionStatus).toBe("MANUAL");
    expect(rows[1]!.resolutionStatus).toBe("AUTO_SELECTED");
  });

  it("selectSourceRow resolves an AWAITING row (candidate) and supports manual", async () => {
    const subId = await seed([{ ordinal: 0, nama: "PT SUMBER DUA", status: "AWAITING_SELECTION" }]);
    await selectSourceRow(subId, 0, { nomorTransaksi: "TX-2", tahun: 2019 }, deps());
    let row = await db.peleburanSourcePt.findUnique({ where: { submissionId_ordinal: { submissionId: subId, ordinal: 0 } } });
    expect(row?.resolutionStatus).toBe("AUTO_SELECTED");
    expect(row?.selectedNomorTransaksi).toBe("TX-2");
    await selectSourceRow(subId, 0, { manual: true }, deps());
    row = await db.peleburanSourcePt.findUnique({ where: { submissionId_ordinal: { submissionId: subId, ordinal: 0 } } });
    expect(row?.resolutionStatus).toBe("MANUAL");
    expect(row?.selectedNomorTransaksi).toBeNull();
  });
});

describe("engine multi-source branch (the throw is GONE)", () => {
  const ids: string[] = [];
  const docIds: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: ids } } });
    await db.document.deleteMany({ where: { id: { in: docIds } } });
  });

  function cfg(): FlowConfig<Record<string, never>> {
    return defineFlow<Record<string, never>>({
      type: "PELEBURAN_PT", engine: "v2-generic",
      primaryAkta: null, skipExtractionTypes: ["OTHER"],
      companyLookup: { mode: "multi-source" }, applyContactInfo: false,
      extraction: {},
      buildContext: async () => ({}),
      rules: [], requiredDocs: [], sections: [],
      rematch: { checklistResetDocTypes: [], standardPtMatchers: false },
      routeFamily: "peleburan", labels: { akta: "x", flow: "x" },
    });
  }

  it("pauses in AWAITING_COMPANY_SELECTION while any row is unresolved; resumes to READY when none", async () => {
    const sub = await db.submission.create({ data: { type: "PELEBURAN_PT", status: "CREATED" } });
    ids.push(sub.id);
    // A pre-seeded AWAITING row: resolvePeleburanSources only touches PENDING rows,
    // so the engine path is exercised without any SABH dependency.
    await db.peleburanSourcePt.create({
      data: { submissionId: sub.id, ordinal: 0, namaPerseroan: "PT AMBIGU", resolutionStatus: "AWAITING_SELECTION" },
    });
    await runFlow(sub.id, cfg());
    expect((await db.submission.findUnique({ where: { id: sub.id } }))?.status).toBe("AWAITING_COMPANY_SELECTION");

    // Resolve the row manually → runFlow again → continues through to READY.
    await db.peleburanSourcePt.update({
      where: { submissionId_ordinal: { submissionId: sub.id, ordinal: 0 } },
      data: { resolutionStatus: "MANUAL" },
    });
    await runFlow(sub.id, cfg());
    expect((await db.submission.findUnique({ where: { id: sub.id } }))?.status).toBe("READY");
  }, 30000);
});