import assert from "node:assert/strict";
import test from "node:test";
import { safeParseServerReportDocument, computeEvidenceHash } from "../src/lib/personal-report-contract.server-core.ts";
import upstreamSourceManifest from "../../references/upstream/yinduzhanxing/source-manifest.json";
import {
  REPORT_STABLE_CODES,
  ReportEvidenceInsufficientError,
  applyReportGuard,
  assembleReportDocument,
  buildReportEvidencePacket,
  canonicalSerialize,
  computeRequestFingerprint,
  findForbiddenDeterministicClaims,
  generatePersonalReport,
  redactDeterministicSentences,
  resolveSkillSnapshot,
  sha256Hex,
  type SkillSnapshot,
} from "../src/lib/personal-report-generation.ts";
import { PRECISE_TIMING_PATTERNS } from "../src/lib/personal-report-generation.ts";
import type {
  PersonalReportAgentOutput,
  ReportAgentPort,
  ReportEvidencePacket,
} from "../src/mastra/personal-report.ts";

// ---------------------------------------------------------------------------
// Fixtures: a real-shaped workflow response matching the Python main chain
// (object-map planets/houses/sections, varga_full D9_Navamsa/D10_Dasamsa)
// ---------------------------------------------------------------------------

function pythonStyleChartPayload() {
  const signNames = ["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo", "Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces"];
  const ascIndex = 4; // Leo
  const planetsMap: Record<string, Record<string, unknown>> = {
    Sun: { sign: "Leo", degree: 142.5, degree_raw: 142.5, degree_in_sign: 22.5, house: 1, retrograde: false, speed: 1.0 },
    Moon: { sign: "Virgo", degree: 172.5, degree_raw: 172.5, degree_in_sign: 22.5, house: 2, retrograde: false, speed: 13.0 },
    Mars: { sign: "Libra", degree: 202.5, degree_raw: 202.5, degree_in_sign: 22.5, house: 3, retrograde: false, speed: 0.6 },
    Mercury: { sign: "Scorpio", degree: 232.5, degree_raw: 232.5, degree_in_sign: 22.5, house: 4, retrograde: true, speed: -0.5 },
    Jupiter: { sign: "Sagittarius", degree: 262.5, degree_raw: 262.5, degree_in_sign: 22.5, house: 5, retrograde: false, speed: 0.2 },
    Venus: { sign: "Capricorn", degree: 292.5, degree_raw: 292.5, degree_in_sign: 22.5, house: 6, retrograde: false, speed: 1.1 },
    Saturn: { sign: "Aquarius", degree: 322.5, degree_raw: 322.5, degree_in_sign: 22.5, house: 7, retrograde: true, speed: -0.1 },
    Rahu: { sign: "Pisces", degree: 352.5, degree_raw: 352.5, degree_in_sign: 22.5, house: 8, retrograde: true, speed: -0.05 },
    Ketu: { sign: "Virgo", degree: 172.5, degree_raw: 172.5, degree_in_sign: 22.5, house: 2, retrograde: true, speed: -0.05 },
  };
  const housesMap: Record<string, Record<string, unknown>> = {};
  for (let index = 0; index < 12; index += 1) {
    housesMap[`house_${index + 1}`] = {
      cusp_sign: signNames[(ascIndex + index) % 12],
      cusp_degree: 140.5 + index * 30,
      lord: signNames[(ascIndex + index) % 12],
    };
  }
  const d9Planets: Record<string, Record<string, unknown>> = {
    Sun: { sign: "Leo", sign_idx: 4 },
    Moon: { sign: "Virgo", sign_idx: 5 },
    Mars: { sign: "Cancer", sign_idx: 3 },
  };
  const d10Planets: Record<string, Record<string, unknown>> = {
    Sun: { sign: "Taurus", sign_idx: 1 },
    Moon: { sign: "Gemini", sign_idx: 2 },
  };
  return {
    success: true,
    chart: {
      ascendant: { sign: "Leo", degree: 20.5, degree_raw: 140.5, lon: 140.5, sign_cn: "狮子座", lord: "Sun" },
      planets: planetsMap,
      houses: housesMap,
      dasha: {
        mahadashas: [
          { lord: "Moon", start: "2019-01-01", end: "2029-01-01" },
          { lord: "Mars", start: "2029-01-01", end: "2036-01-01" },
        ],
      },
      modules: {
        varga_full: {
          D9_Navamsa: {
            _meta: { div: 9 },
            Ascendant: { sign: "Leo", sign_idx: 4 },
            ...d9Planets,
            _dignity: {},
          },
          D10_Dasamsa: {
            _meta: { div: 10 },
            Ascendant: { sign: "Taurus", sign_idx: 1 },
            ...d10Planets,
          },
        },
        narayana_dasha: {
          periods: [{ lord: "Sun", start: "2023-01-01", end: "2026-01-01" }],
        },
      },
    },
    consumer_context: {
      route: "general",
      core_status: "ready",
      available_layers: ["D1", "D9", "D10", "Vimshottari", "Narayana"],
      missing_route_layers: [],
      hard_blockers: [],
      answer_policy: {
        can_answer_precise_timing: true,
        deterministic_claims_forbidden_for: [],
      },
    },
    machine_evidence_packet: {
      conflicts: [
        { techniques: ["Vimshottari", "Narayana"], summary: "两个大运系统给出的阶段边界不一致" },
      ],
      sections: {
        D1: { status: "used", source_path: "chart.planets+chart.ascendant" },
        D9: { status: "used", source_path: "modules.varga_full.D9" },
        D10: { status: "used", source_path: "modules.varga_full.D10" },
        D2: { status: "missing", source_path: "modules.varga_full.D2" },
        planet_degrees: { status: "used", source_path: "chart.planets" },
        house_degrees: { status: "used", source_path: "chart.houses" },
        dasha_boundaries: { status: "used", source_path: "modules.dasha" },
        narayana_dasha: { status: "used", source_path: "modules.narayana_dasha" },
        external_oracle_status: { status: "used", source_path: "vedastro_official.runtime_truth" },
        vedastro_official_raw_response: { status: "missing", source_path: "vedastro_official.raw_response" },
      },
    },
  };
}

function buildPacket(overrides: Partial<BuildPacketOverrides> = {}): ReportEvidencePacket {
  const workflow = overrides.workflow ?? pythonStyleChartPayload();
  return buildReportEvidencePacket({
    workflow,
    subject: {
      displayName: "测试用户",
      birthTimeStatus: "confirmed",
      birthPlaceLabel: "北京",
    },
    requestedThemes: ["career", "marriage", "wealth", "timing"],
    reportType: "personal_full",
    presentationMode: "default",
    candidateRange: null,
    skillSnapshot: { sha256: "a".repeat(64), sourceCommit: "b".repeat(40) },
  });
}

type BuildPacketOverrides = {
  workflow: unknown;
};

function agentOutput(overrides: Partial<PersonalReportAgentOutput> = {}): PersonalReportAgentOutput {
  return {
    executiveSummary: {
      headline: "综合盘面以事业发展为主线",
      summary: "命盘显示事业层面具备稳定的结构，财富与婚恋需结合分盘审慎解读。",
      priorities: ["先聚焦职业方向", "再核对感情与财富主题"],
    },
    thematicNarrative: [
      {
        id: "career",
        title: "事业",
        narrative: "事业层面以十宫与 D10 结构为主，方向性判断稳定，具体应期需要结合大运边界观察。",
        actions: ["在稳定领域深耕"],
        caveats: ["该部分为方向性描述"],
        claimStatus: "single_system_inference",
        evidenceRefs: ["ev-audit-1", "ev-audit-3"],
      },
      {
        id: "marriage",
        title: "婚恋",
        narrative: "婚恋部分以七宫与 D9 为主，呈现结构特征，不构成确定性结论。",
        actions: [],
        caveats: [],
        claimStatus: "single_system_inference",
        evidenceRefs: ["ev-audit-2"],
      },
    ],
    ...overrides,
  };
}

// ---------------------------------------------------------------------------
// Packet builder: allowlist + fail-closed
// ---------------------------------------------------------------------------

test("packet builder extracts only allowlisted facts, never internal noise", () => {
  const workflow = pythonStyleChartPayload();
  (workflow as Record<string, unknown>).internal_path = "/opt/app/private/engine.py";
  (workflow as Record<string, unknown>).prompt_text = "系统提示词原文";
  (workflow as Record<string, unknown>).traceback = "Traceback (most recent call last)";
  (workflow as Record<string, unknown>).raw_payload = { anything: true };
  const packet = buildPacket({ workflow });
  const serialized = JSON.stringify(packet);
  assert.doesNotMatch(serialized, /internal_path|prompt_text|traceback|raw_payload|\/opt\/app/);
  assert.match(serialized, /ev-audit-/);
  assert.match(serialized, /ev-conflict-/);
});

test("packet builder computes a canonical 64-hex calculation hash and marks derivation", () => {
  const packet = buildPacket();
  assert.match(packet.chart.calculationHash, /^[0-9a-f]{64}$/);
  assert.equal(packet.chart.calculationHashDerived, true);
});

test("packet builder keeps a real engine hash when present", () => {
  const workflow = pythonStyleChartPayload() as Record<string, unknown>;
  const chart = workflow.chart as Record<string, unknown>;
  chart.result_hash = "c".repeat(64);
  const packet = buildPacket({ workflow });
  assert.equal(packet.chart.calculationHash, "c".repeat(64));
  assert.equal(packet.chart.calculationHashDerived, false);
});

test("packet builder fails closed without real D1 houses", () => {
  const workflow = pythonStyleChartPayload() as Record<string, unknown>;
  const chart = workflow.chart as Record<string, unknown>;
  const houses = chart.houses as Record<string, unknown>;
  delete houses["house_9"];
  delete houses["house_10"];
  delete houses["house_11"];
  delete houses["house_12"];
  assert.throws(() => buildPacket({ workflow }), ReportEvidenceInsufficientError);
});

test("packet builder fails closed without retrograde facts", () => {
  const workflow = pythonStyleChartPayload() as Record<string, unknown>;
  const chart = workflow.chart as Record<string, unknown>;
  const planets = chart.planets as Record<string, Record<string, unknown>>;
  planets.Sun.retrograde = undefined;
  assert.throws(() => buildPacket({ workflow }), ReportEvidenceInsufficientError);
});

test("packet builder fails closed without ascendant or evidence refs", () => {
  const workflow = pythonStyleChartPayload() as Record<string, unknown>;
  const chart = workflow.chart as Record<string, unknown>;
  delete chart.ascendant;
  assert.throws(() => buildPacket({ workflow }), ReportEvidenceInsufficientError);

  const workflow2 = pythonStyleChartPayload() as Record<string, unknown>;
  const consumer = workflow2.consumer_context as Record<string, unknown>;
  consumer.available_layers = [];
  const machine = workflow2.machine_evidence_packet as Record<string, unknown>;
  machine.sections = {};
  machine.conflicts = [];
  assert.throws(() => buildPacket({ workflow: workflow2 }), ReportEvidenceInsufficientError);
});

test("no mock fallback: an empty workflow never yields a usable packet", () => {
  assert.throws(() => buildPacket({ workflow: {} }), ReportEvidenceInsufficientError);
});

test("packet builder normalizes the real Python object-map shapes", () => {
  const packet = buildPacket();
  // planets object map -> facts, absolute longitude from degree/degree_raw.
  assert.equal(packet.chart.planets.length, 9);
  const sun = packet.chart.planets.find((planet) => planet.id === "Sun");
  assert.ok(sun);
  assert.equal(sun.sign, "Leo");
  assert.equal(sun.degree, 142.5);
  assert.equal(sun.house, 1);
  assert.equal(sun.retrograde, false);
  assert.equal(packet.chart.planets.find((planet) => planet.id === "Saturn")?.retrograde, true);
  // houses object map (cusp_sign only) -> whole-sign derived signs, marked.
  assert.equal(packet.chart.houses.length, 12);
  assert.equal(packet.chart.houses[0].sign, "Leo");
  assert.equal(packet.chart.houses[0].signDerived, true);
  assert.deepEqual(packet.chart.houses[0].occupants, ["Sun"]);
  assert.equal(packet.chart.houses[1].sign, "Virgo");
  assert.deepEqual([...packet.chart.houses[1].occupants].sort(), ["Ketu", "Moon"]);
  // sections object map -> deterministic statuses: core calculation sections
  // verified, internal layers partial, external/missing degraded.
  const refs = packet.evidenceRefs;
  const verified = refs.filter((ref) => ref.status === "verified").map((ref) => ref.technique);
  assert.ok(verified.includes("planet_degrees"));
  assert.ok(verified.includes("house_degrees"));
  const blocked = refs.filter((ref) => ref.status === "blocked").map((ref) => ref.technique);
  assert.ok(blocked.includes("D2"));
  assert.ok(blocked.includes("vedastro_official_raw_response"));
  const partial = refs.filter((ref) => ref.status === "partial").map((ref) => ref.technique);
  assert.ok(partial.includes("dasha_boundaries"));
  assert.ok(partial.includes("external_oracle_status"));
  // conflicts produce canonical ev-conflict refs.
  assert.ok(refs.some((ref) => ref.id.startsWith("ev-conflict-")));
});

test("packet builder resolves the base chart from modules.chart and nested chart", () => {
  const base = pythonStyleChartPayload() as Record<string, unknown>;
  const chartData = base.chart as Record<string, unknown>;
  // modules.chart wins over nested chart over top level.
  const modulesChart = {
    ...chartData,
    planets: { Sun: { sign: "Aries", degree: 10.5, degree_raw: 10.5, house: 1, retrograde: false } },
  };
  const modules = chartData.modules as Record<string, unknown>;
  modules.chart = modulesChart;
  const viaModules = buildPacket({ workflow: base });
  assert.equal(viaModules.chart.planets.length, 1);
  assert.equal(viaModules.chart.planets[0].sign, "Aries");
  delete modules.chart;

  // nested chart_data.chart is the orchestrator's second choice.
  const nested = {
    ...chartData,
    planets: { Moon: { sign: "Pisces", degree: 350.5, degree_raw: 350.5, house: 12, retrograde: false } },
  };
  chartData.chart = nested;
  const viaNested = buildPacket({ workflow: base });
  assert.equal(viaNested.chart.planets.length, 1);
  assert.equal(viaNested.chart.planets[0].id, "Moon");
});

test("varga houses are whole-sign derived from the divisional ascendant, never fabricated", () => {
  const packet = buildPacket();
  const d9 = packet.chart.vargaHouses.find((varga) => varga.id === "D9");
  assert.ok(d9);
  assert.equal(d9.houses.length, 12);
  // D9 ascendant is Leo (index 4): house 1 Leo, house 2 Virgo.
  assert.equal(d9.houses[0].sign, "Leo");
  assert.equal(d9.houses[1].sign, "Virgo");
  // Moon sits in Virgo (index 5) -> whole-sign house 2 of D9.
  assert.ok(d9.houses[1].occupants.includes("Moon"));
  assert.ok(d9.houses.every((house) => house.signDerived === true));
  const d10 = packet.chart.vargaHouses.find((varga) => varga.id === "D10");
  assert.ok(d10);
  // D10 ascendant is Taurus (index 1): house 1 Taurus, house 2 Gemini.
  assert.equal(d10.houses[0].sign, "Taurus");
  assert.equal(d10.houses[1].sign, "Gemini");
  assert.ok(d10.houses[1].occupants.includes("Moon"));
});

test("array-shaped chart data remains supported", () => {
  const workflow = {
    success: true,
    chart: {
      ascendant: { sign: "Leo", degree: 12.5 },
      planets: [
        { id: "Sun", sign: "Leo", degree: 142.5, house: 1, retrograde: false },
        { id: "Moon", sign: "Virgo", degree: 172.5, house: 2, retrograde: false },
      ],
      houses: Array.from({ length: 12 }, (_, index) => ({
        number: index + 1,
        sign: ["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo", "Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces"][index],
      })),
    },
    consumer_context: {
      route: "general",
      core_status: "ready",
      available_layers: ["D1"],
      missing_route_layers: [],
      hard_blockers: [],
      answer_policy: { can_answer_precise_timing: true, deterministic_claims_forbidden_for: [] },
    },
    machine_evidence_packet: {
      conflicts: [],
      sections: [{ name: "planet_degrees", status: "verified", note: "" }],
    },
  };
  const packet = buildPacket({ workflow });
  assert.equal(packet.chart.planets.length, 2);
  assert.equal(packet.chart.houses.length, 12);
  // Array houses carry a real sign: not derived.
  assert.equal(packet.chart.houses[0].signDerived, false);
  assert.equal(packet.chart.houses[0].sign, "Aries");
  assert.ok(packet.evidenceRefs.some((ref) => ref.status === "verified"));
});

test("section status mapping is deterministic (used core sections verified, external degraded)", () => {
  const packet = buildPacket();
  const byTechnique = new Map(packet.evidenceRefs.map((ref) => [ref.technique, ref.status]));
  assert.equal(byTechnique.get("D1"), "verified");
  assert.equal(byTechnique.get("planet_degrees"), "verified");
  assert.equal(byTechnique.get("house_degrees"), "verified");
  assert.equal(byTechnique.get("dasha_boundaries"), "partial");
  assert.equal(byTechnique.get("external_oracle_status"), "partial");
  assert.equal(byTechnique.get("D2"), "blocked");
  assert.equal(byTechnique.get("vedastro_official_raw_response"), "blocked");
});

// ---------------------------------------------------------------------------
// Fingerprint
// ---------------------------------------------------------------------------

test("request fingerprint is canonical: sorted, deduped themes, no requestId", () => {
  const base = {
    reportType: "personal_full",
    presentationMode: "default",
    themes: ["wealth", "career", "wealth", "timing"],
    sessionId: null,
    chartProfileId: null,
  };
  const fingerprintA = computeRequestFingerprint(base);
  const fingerprintB = computeRequestFingerprint({
    reportType: "personal_full",
    presentationMode: "default",
    themes: ["career", "timing", "wealth"],
    sessionId: null,
    chartProfileId: null,
  });
  assert.equal(fingerprintA, fingerprintB);
  assert.equal(fingerprintA, sha256Hex(canonicalSerialize({
    reportType: "personal_full",
    presentationMode: "default",
    themes: ["career", "timing", "wealth"],
    sessionId: null,
    chartProfileId: null,
  })));
  const differentType = computeRequestFingerprint({
    ...base,
    reportType: "personal_thematic",
  });
  assert.notEqual(fingerprintA, differentType);
  const withSession = computeRequestFingerprint({
    ...base,
    sessionId: "11111111-1111-4111-8111-111111111111",
  });
  assert.notEqual(fingerprintA, withSession);
});

// ---------------------------------------------------------------------------
// Assembly: canonical contract shape
// ---------------------------------------------------------------------------

test("assembled document passes the canonical server parse with a D1 of 12 houses", () => {
  const packet = buildPacket();
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet,
    agentOutput: agentOutput(),
  });
  const parsed = safeParseServerReportDocument(document);
  assert.equal(parsed.ok, true);
  if (!parsed.ok) return;
  assert.equal(parsed.document.charts.length, 3);
  const d1 = parsed.document.charts.find((chart) => chart.id === "D1");
  assert.ok(d1);
  assert.equal(d1.houses.length, 12);
  assert.deepEqual(
    d1.houses.map((house) => house.houseNumber).sort((a, b) => a - b),
    Array.from({ length: 12 }, (_, index) => index + 1),
  );
  assert.ok(d1.planets && d1.planets.length === 9);
  assert.equal(d1.planets[0].retrograde, false);
  assert.equal(d1.planets[6].retrograde, true);
  // Appendix ids are canonical ev- ids and globally unique.
  const ids = [
    ...parsed.document.evidenceAppendix.techniqueAudit.map((row) => row.id),
    ...parsed.document.evidenceAppendix.conflicts.map((row) => row.id),
    ...parsed.document.evidenceAppendix.calculationEvidence.map((row) => row.id),
  ];
  assert.equal(new Set(ids).size, ids.length);
  assert.ok(ids.every((id) => /^ev-[a-z0-9_-]{1,63}$/.test(id)));
  // evidenceHash matches the canonical recomputation from the appendix.
  assert.equal(
    parsed.document.provenance.evidenceHash,
    computeEvidenceHash(parsed.document.evidenceAppendix),
  );
});

test("D9/D10 charts are omitted when no real divisional houses exist", () => {
  const workflow = pythonStyleChartPayload() as Record<string, unknown>;
  const chart = workflow.chart as Record<string, unknown>;
  const modules = chart.modules as Record<string, unknown>;
  modules.varga_full = {};
  const packet = buildPacket({ workflow });
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet,
    agentOutput: agentOutput(),
  });
  const parsed = safeParseServerReportDocument(document);
  assert.equal(parsed.ok, true);
  if (!parsed.ok) return;
  assert.deepEqual(parsed.document.charts.map((chartRow) => chartRow.id), ["D1"]);
});

// ---------------------------------------------------------------------------
// Deterministic guard
// ---------------------------------------------------------------------------

test("guard rejects dangling evidence refs", () => {
  const packet = buildPacket();
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet,
    agentOutput: agentOutput({
      thematicNarrative: [
        {
          id: "career",
          title: "事业",
          narrative: "稳定结构。",
          actions: [],
          caveats: [],
          claimStatus: "single_system_inference",
          evidenceRefs: ["ev-audit-999"],
        },
      ],
    }),
  });
  const guarded = applyReportGuard(document, packet);
  assert.equal(guarded.ok, false);
  if (!guarded.ok) assert.match(guarded.reason, /unresolved_evidence_ref/);
});

test("guard redacts precise timing and downgrades the section when timing is blocked", () => {
  const packet = buildPacket();
  const timingBlockedPacket = { ...packet, answerPolicy: { ...packet.answerPolicy, canAnswerPreciseTiming: false } };
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet: timingBlockedPacket,
    agentOutput: agentOutput({
      thematicNarrative: [
        {
          id: "career",
          title: "事业",
          narrative: "方向稳定。2027年3月将迎来事业转折，届时务必把握机会。",
          actions: ["2027年3月跳槽"],
          caveats: [],
          claimStatus: "single_system_inference",
          evidenceRefs: ["ev-audit-1"],
        },
      ],
    }),
  });
  const guarded = applyReportGuard(document, timingBlockedPacket);
  assert.equal(guarded.ok, true);
  if (!guarded.ok) return;
  const section = (guarded.document as unknown as { thematicNarrative: { narrative: string; claimStatus: string; caveats: string[] }[] })
    .thematicNarrative[0];
  assert.doesNotMatch(section.narrative, /2027年3月/);
  assert.equal(section.claimStatus, "blocked");
  assert.ok(section.caveats.some((caveat) => caveat.includes("确定性边界")));
});

test("guard rejects medical deterministic claims outright", () => {
  const packet = buildPacket();
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet,
    agentOutput: agentOutput({
      thematicNarrative: [
        {
          id: "career",
          title: "事业",
          narrative: "你一定会患上心脏病。",
          actions: [],
          caveats: [],
          claimStatus: "single_system_inference",
          evidenceRefs: ["ev-audit-1"],
        },
      ],
    }),
  });
  const guarded = applyReportGuard(document, packet);
  assert.equal(guarded.ok, false);
  if (!guarded.ok) assert.match(guarded.reason, /deterministic_medical_claim/);
});

test("guard rejects investment deterministic claims hidden in actions", () => {
  const packet = buildPacket();
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet,
    agentOutput: agentOutput({
      thematicNarrative: [
        {
          id: "wealth",
          title: "财富",
          narrative: "财富结构稳定。",
          actions: ["买入股票必然大涨"],
          caveats: [],
          claimStatus: "single_system_inference",
          evidenceRefs: ["ev-audit-1"],
        },
      ],
    }),
  });
  const guarded = applyReportGuard(document, packet);
  assert.equal(guarded.ok, false);
  if (!guarded.ok) assert.match(guarded.reason, /deterministic_investment_claim/);
});

test("guard forces blocked when every evidence ref is blocked", () => {
  const workflow = pythonStyleChartPayload() as Record<string, unknown>;
  const consumer = workflow.consumer_context as Record<string, unknown>;
  consumer.hard_blockers = ["Narayana"];
  consumer.available_layers = ["D1", "Vimshottari"];
  const packet = buildPacket({ workflow });
  const blockedRef = packet.evidenceRefs.find((ref) => ref.status === "blocked");
  assert.ok(blockedRef);
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet,
    agentOutput: agentOutput({
      thematicNarrative: [
        {
          id: "timing",
          title: "时机",
          narrative: "该部分仅保留方向性说明。",
          actions: [],
          caveats: [],
          claimStatus: "single_system_inference",
          evidenceRefs: [blockedRef.id],
        },
      ],
    }),
  });
  const guarded = applyReportGuard(document, packet);
  assert.equal(guarded.ok, true);
  if (!guarded.ok) return;
  const section = (guarded.document as unknown as { thematicNarrative: { id: string; claimStatus: string }[] })
    .thematicNarrative[0];
  assert.equal(section.claimStatus, "blocked");
});

test("guard redacts timing from the summary and blocks the report-level status", () => {
  const packet = buildPacket();
  const timingBlockedPacket = { ...packet, answerPolicy: { ...packet.answerPolicy, canAnswerPreciseTiming: false } };
  const document = assembleReportDocument({
    reportId: "22222222-2222-4222-8222-222222222222",
    generatedAt: "2026-08-06T00:00:00.000Z",
    packet: timingBlockedPacket,
    agentOutput: agentOutput({
      executiveSummary: {
        headline: "综合盘面以事业发展为主线",
        summary: "明年3月将迎来关键转折，整体结构稳定。",
        priorities: ["先聚焦职业方向"],
      },
    }),
  });
  const guarded = applyReportGuard(document, timingBlockedPacket);
  assert.equal(guarded.ok, true);
  if (!guarded.ok) return;
  const summary = (guarded.document as unknown as { executiveSummary: { summary: string; overallClaimStatus: string } })
    .executiveSummary;
  assert.doesNotMatch(summary.summary, /明年3月/);
  assert.equal(summary.overallClaimStatus, "blocked");
});

test("findForbiddenDeterministicClaims and redaction are deterministic", () => {
  assert.ok(findForbiddenDeterministicClaims("2027年3月会发生转折").some((claim) => claim.domain === "timing"));
  assert.ok(findForbiddenDeterministicClaims("投资必然赚钱").some((claim) => claim.domain === "investment"));
  assert.equal(findForbiddenDeterministicClaims("方向性判断稳定").length, 0);
  const redacted = redactDeterministicSentences("方向稳定。2027年3月转折。", PRECISE_TIMING_PATTERNS);
  assert.equal(redacted.removedCount, 1);
  assert.doesNotMatch(redacted.text, /2027年3月/);
});

// ---------------------------------------------------------------------------
// Generation pipeline (fake agent, real canonical parse)
// ---------------------------------------------------------------------------

function fakeAgent(output: PersonalReportAgentOutput, calls: { count: number }): ReportAgentPort {
  return {
    modelId: "test-model",
    async generate() {
      calls.count += 1;
      return output;
    },
  };
}

test("generatePersonalReport returns a ready document that passes the server parse", async () => {
  const packet = buildPacket();
  const calls = { count: 0 };
  const result = await generatePersonalReport({
    reportId: "22222222-2222-4222-8222-222222222222",
    packet,
    agent: fakeAgent(agentOutput(), calls),
    now: () => new Date("2026-08-06T00:00:00.000Z"),
  });
  assert.equal(calls.count, 1);
  assert.equal(result.status, "ready");
  if (result.status !== "ready") return;
  assert.match(result.evidenceHash, /^[0-9a-f]{64}$/);
  const reparsed = safeParseServerReportDocument(result.document);
  assert.equal(reparsed.ok, true);
});

test("generatePersonalReport fails with report_guard_rejected on guard rejection", async () => {
  const packet = buildPacket();
  const result = await generatePersonalReport({
    reportId: "22222222-2222-4222-8222-222222222222",
    packet,
    agent: fakeAgent(agentOutput({
      thematicNarrative: [
        {
          id: "career",
          title: "事业",
          narrative: "你必定会胜诉。",
          actions: [],
          caveats: [],
          claimStatus: "single_system_inference",
          evidenceRefs: ["ev-audit-1"],
        },
      ],
    }), { count: 0 }),
  });
  assert.deepEqual(result, { status: "failed", failureCode: "report_guard_rejected" });
});

test("generatePersonalReport fails with report_schema_invalid when the final parse rejects", async () => {
  const workflow = pythonStyleChartPayload() as Record<string, unknown>;
  const consumer = workflow.consumer_context as Record<string, unknown>;
  consumer.hard_blockers = ["Narayana"];
  consumer.available_layers = ["D1", "Vimshottari"];
  const packet = buildPacket({ workflow });
  const blockedRef = packet.evidenceRefs.find((ref) => ref.status === "blocked");
  assert.ok(blockedRef);
  const result = await generatePersonalReport({
    reportId: "22222222-2222-4222-8222-222222222222",
    packet,
    agent: fakeAgent(agentOutput({
      thematicNarrative: [
        {
          id: "timing",
          title: "时机",
          narrative: "该部分必然会成功，结构稳定。",
          actions: [],
          caveats: [],
          claimStatus: "single_system_inference",
          evidenceRefs: [blockedRef.id],
        },
      ],
    }), { count: 0 }),
    now: () => new Date("2026-08-06T00:00:00.000Z"),
  });
  // The guard downgrades the section to blocked (all refs blocked); the
  // blocked section still contains the deterministic phrase 必然, so the FINAL
  // canonical server parse rejects it. Guard mutations are always re-validated.
  assert.equal(result.status, "failed");
  if (result.status === "failed") assert.equal(result.failureCode, "report_schema_invalid");
});

test("skill snapshot is the real packaged manifest sha256, never the literal unknown", async () => {
  const snapshot: SkillSnapshot = resolveSkillSnapshot();
  const manifest = upstreamSourceManifest as { skill_sha256?: string };
  assert.match(snapshot.sha256, /^[0-9a-f]{64}$/);
  assert.notEqual(snapshot.sha256, "unknown");
  assert.equal(snapshot.sha256, manifest.skill_sha256);
  const again: SkillSnapshot = resolveSkillSnapshot();
  assert.equal(snapshot.sha256, again.sha256);
});

test("stable codes include the request-conflict mapping", () => {
  assert.equal(REPORT_STABLE_CODES.requestConflict, "report_request_conflict");
});