Claims Processing & Adjudication

Libraries: claims, clmentry, clmforms, clmprint, clmrpt, clmshare, clmsproc, clmutils (94 windows, 553 DataWindows). Requirement prefix: CLM.

Screen-level detail is split across three companion pages: Entry, Correction & Editor, Search, Accums, Audit, Letters & Ops, and Reports & Print.

Purpose & business capability

This is the core module of HOMER. It captures health-benefit claims on form-specific entry screens (HCFA‑1500, UB92, dental, vision, drug, FSA/reimbursement, weekly-disability, repricing sheets, and others), moves each claim through a staged processing pipeline (corrections → code review → pre-adjudication → duplicate check → pricing → adjudication → payment allocation → audit → funding → paid), automatically applies plan benefit rules (exclusions, copays, deductibles, coinsurance, out-of-pocket, claimed/paid limits, holds), maintains member/family accumulators, coordinates benefits with other carriers, produces EOBs, member/provider letters and operational reports, and hands finished claims to the Funding module (fund register / check issuance). It also stages claims for outbound EDI to trading partners (e.g. PPO networks for repricing).

The pipeline stages themselves are executed by a background batch process (user id SFPIBACK appears throughout as the automated actor); the screens in this module are used to enter claims, correct errors raised as claim messages, override system decisions, and monitor the pipeline. The adjudication engine itself (clmsproc/n_claim_adjudication, 8,800+ lines) lives in this domain and is invoked both by the batch process and by interactive "send back to corrections" logic.

Actors

Actor	Evidence
Claims entry operator ("claim person")	claim id embeds first 3 chars of the entering user's id (clmshare/n_cst_claims, of_getnewclaimid)
Claims examiner	claims.claim_examiner_sys_key / claim_examiner_userid columns (clmshare/d_claims_master); examiner audit setup (claims/w_audit_examiners_selection)
Claims auditor	Audit status screens (claims/w_claim_editor "Claims Audit" mode; claims/w_setstatusfromaudit)
Claims supervisor / MIS	claim unlock (claims/w_claims_unlock), background monitor (clmutils/w_bkgd_monitor), rule utilities (clmutils/w_adjd_rule_utils)
Background batch process (SFPIBACK)	messages closed by sfpiback treated specially (clmsproc/n_claim_adjudication, of_adjudicateclaims); pricing rules created by SFPIBACK deleted on reset (clmshare/n_cst_return_claim_to_corrections)
Security-restricted user groups	group-level claim access; Returned Claims / develop groups may open RETURN/DELETE/UNIDENT claims (clmshare/n_cst_claim_control, of_checksecurityaccess)

Key workflows

Claim lifecycle (status pipeline)

The pipeline order and display names are data-driven from table claim_status_order (clmshare/d_claim_status_order, used by clmshare/n_claims_status). The nine processing stages monitored by the background monitor are hard-coded in clmutils/w_bkgd_monitor (dw_status_counts, pfc_retrieve):

ls_status = {'RFCP', 'RFCR', 'RFPA', 'RFDC', 'RFPR', 'RFA', 'RFAL', 'RFCA', 'RFF'}
ls_desc   = {'Corrections', 'CodeReview', 'Pre-Adjd', 'DupCheck', 'Pricing', 'Adjudication', 'Pmt Alloc', 'Audit', 'Funding'}

Statuses evidenced in code, beyond the nine pipeline stages: PAID, and the sub-statuses VOID, RETURN, DELETE, UNIDENT (claims/w_setclaimsstatus; clmshare/n_cst_claim_control of_checksecurityaccess), the HOLD variants formed by appending HOLD to a status (e.g. RFCPHOLD, RFAHOLD — clmshare/n_cst_claims of_setclaimsstatus strips the trailing "HOLD"; clmsproc/n_claim_adjudication references RFAHOLD), and REXOUT for electronically paid claims released from audit (clmshare/n_cst_claims, of_closemessage case 151).

Notes on the diagram: transitions between adjacent pipeline stages other than those cited are performed by the background batch application, which is outside these libraries (see Open questions). "Send back to corrections" (clmshare/n_cst_return_claim_to_corrections) is possible from any status above RFCPHOLD until funding data exists.

Stage behavior evidenced in this domain

1. Entry (→ RFCP). A claim is captured on a form-specific tab object; on first save it receives a generated claim id and status RFCP (clmshare/n_cst_claims, of_setnewclaim / of_getnewclaimid / of_save).
2. Corrections (RFCP). Errors raised by the pipeline appear as claim messages (claim_messages); the Claims Correction screen retrieves claims with open messages and drives resolution message-by-message (claims/w_claim_correction, clmshare/n_cst_claims of_closemessage).
3. Pre-adjudication (RFPA). clmsproc/n_claim_adjudication.of_processclaimdef assigns a benefit definition to every claim line from the benefit package's prioritized definition list, corrects UB92 room & board dates, performs whole-claim (per-diem) pricing for qualifying repricing sheets, and performs accident-record checking.
4. Duplicate check (RFDC). Lines flagged duplicate_claim_line_ind = 'Y' are rejected with the system duplicate reason; message 102 carries the list of candidate duplicate claim ids (DupClaims: system comment) for examiner disposition (clmsproc/n_claim_adjudication of_adjudicateclaims; clmshare/n_cst_claims of_closemessage case 102; claims/u_duplicate_claim).
5. Pricing (RFPR). Allowed amounts / write-offs are produced by the Pricing module (outside this domain); adjudication consumes allowed_amt and manual pricing entries from claim_line_pricing_rules (claims/w_claim_line_pricing_rules).
6. Adjudication (RFA). of_adjudicateclaims + of_applypackage + of_applyrule apply the benefit package's rules to each line, write claim_line_rules, claim_line_accums and member_accums, apply COB, and compute the payable waterfall.
7. Payment allocation (RFAL) & payment status. Fund-register rows (payments) are shown on the claim's Payment tab (clmentry/u_payment, DataWindow d_claim_history); missing-vendor message 140 sends a claim back for reprocessing (clmshare/n_cst_claims of_closemessage case 140).
8. Audit (RFCA). Claims selected for audit are held by message 151/171; release requires every other message closed and moves the claim to RFF (or REXOUT) or back to RFCP (claims/w_setstatusfromaudit; clmshare/n_cst_claims case 151).
9. Funding (RFF → PAID). Handled by the Funding module; this module enforces read-only behavior once funding data exists (clmshare/n_cst_claim_control, of_getfundingstatus).

Adjudication engine flow (per claim line)

(All nodes: clmsproc/n_claim_adjudication.)

Business rules (requirements)

Claim identity, locking and access

1. CLM-1 The system shall generate claim identifiers as origin code + 3-character user tag + Julian date (YYYYDDD) + 6-digit sequence number drawn from the Oracle sequence claim_seq. The user tag is the caller-supplied claim-id user tag where one is set, falling back to the first 3 characters of the entering user's id (clmshare/n_cst_claims, of_getnewclaimid). Guide note: the origin code identifies how the claim entered the system — E = EDI, K = Keyed, S = Scanned, O = Outsourced keypunch, W = Wang history — and origin code + user tag + Julian date together form the batch number under which the hardcopy is filed; operators must hand-write the generated claim number on each physical form at entry (User Guide ch. 10).
2. CLM-2 The system shall set every newly created claim to Corrections status (RFCP) (clmshare/n_cst_claims, of_setnewclaim).
3. CLM-3 The system shall place a logical lock (lock_seq_no drawn from sequence logical_lock_seq) on a claim before it may be edited, and shall open a claim locked by another user in read-only mode after warning the user who holds the lock (clmshare/n_cst_claim_control, of_setclaimlockid, of_getlockstatus).
4. CLM-4 Batch processing shall refuse to pre-adjudicate or adjudicate claims that are not locked (clmsproc/n_claim_adjudication, of_processclaimdef, of_adjudicateclaims).
5. CLM-5 The system shall permit a user to open a claim only when (a) the claim's group is in the user's security groups, or (b) the claim has no group and was created by the user, or (c) the claim is in DELETE/RETURN/UNIDENT status and the user belongs to the Returned Claims or develop security group (clmshare/n_cst_claim_control, of_checksecurityaccess).
6. CLM-6 A claim searched by an external claim id shall be resolved to its internal claim id before locking (clmshare/n_cst_claim_control, of_getlockstatus).
7. CLM-7 A claim in PAID status or later shall always open read-only ("Read Only - Paid") (clmshare/n_cst_claim_control, of_getfundingstatus).
8. CLM-8 A claim at Funding status (RFF) or later with no actual funding activity shall open read-only but remain returnable to corrections; a claim with actual payment activity (a fund-register row that is not backed out, whose payment type is not EXPECTED/PREPAID/FICA/MATCH FICA/FITW/SITW/LITW/UNEMPLOY/MISC, and that has a non-zero non-worksheet paid amount or a paid date) shall open read-only and shall not be returnable (clmshare/n_cst_claim_control, of_getfundingstatus).

Status management

9. CLM-9 Claim status ordering and screen groupings shall be data-driven from the claim-status-order table so screens can validate that a claim is still in the status family they service (clmshare/n_claims_status; clmshare/d_claim_status_order).
10. CLM-10 From the claim editor a user shall be able to Void, Return, Mark-for-Deletion, Reactivate (to RFCP), or Hold a claim, each action requiring confirmation and writing an informational claim message (Void=88, Return=87, Reactivate=89, Delete=144, Hold=86) (claims/w_claim_editor wf_setstatus; claims/w_setclaimsstatus).
11. CLM-11 Returning a claim shall currently mark it for deletion instead ("All claims sent to 'Return' status are now automatically being Marked for Deletion") (claims/w_setclaimsstatus, open event).
12. CLM-12 Placing a claim on hold shall append HOLD to its current status; removing hold shall strip the suffix and close message 86, which cannot be closed manually (clmshare/n_cst_claims, of_setclaimsstatus, of_closemessage case 86).
13. CLM-13 The Void action shall be disabled for any claim that has ever reached PAID status (checked against claim status history) (claims/w_claim_editor, ue_setscreenstatus and wf_setstatus).
14. CLM-14 When a claim above RFCPHOLD is edited in a way that requires reprocessing, or its status is manually set below RFCP, the system shall reset the claim: status to RFCP; every line's status, duplicate flag and reject reason cleared and code-review flag set; fund-register rows backed out (backout_ind='Y', register status cleared, backout date stamped when not yet on a register); claim line rules and accumulators deleted with member accumulators decremented; internal-CM service usage decremented and claim/service links removed; messages closed except control code DONOTCLOSE and deleted for DELONRESET; system-generated (SFPIBACK) pricing rules deleted; outstanding claim letters archived when moving to a sub-status (clmshare/n_cst_return_claim_to_corrections, of_returntocorrections; clmshare/n_cst_claims, of_resetclaim).
15. CLM-15 After a pipeline stage completes with no open messages the system shall advance the claim status: to RFDC (unless the claim is VOID/RETURN), and from RFA to RFAL (clmsproc/n_claim_adjudication, of_update_claim_status, of_update_adjudication_status).

Entry & validation

16. CLM-16 Each claim shall be captured on the entry form matching its claim form type; the supported types are HCFA1500, HCFA_REPRICE, UB92, UB92_REPRICE_IN, UB92_REPRICE_OUT, GENERIC_REPRICE, GENERIC_MEDICAL, GENERIC_DENTAL, DED_SUPPLEMENT, SFPI_DENTAL, SFPI_VISION_EXAM, SFPI_VISION, SFPI_HCR, SFPI_DEPENDENT, SFPI_WDI, SFPI_INELIGIBLE, DRUG, SSO (clmshare/n_cst_claimform, of_getclaimsobject).
17. CLM-17 Saving a claim shall persist header, entry, diagnosis, line, pricing-rule, form-specific (UB92/HCFA/dental/vision/reimbursement/WDI/SSO/reprice), adjudication, message and fund-register data in a single transaction in referential order, rolling back everything on any failure (clmshare/n_cst_claims, of_save).
18. CLM-18 Deleting a claim line shall return the claim to RFCP and delete the claim's line diagnosis codes so the background process can rebuild them (clmshare/n_cst_claims, of_save).
19. CLM-19 The system shall validate required fields at save and record a claim message per missing field; a claim shall not be advanced to Funding while any error message is open (clmshare/n_cst_claims, of_save / of_checkrequiredfields).
20. CLM-20 For anesthesia procedure codes the entry screen shall capture start/end time and compute total units from base units + time units + modifier units with a unit conversion factor (clmentry/w_anesthesia_popup; clmentry/d_anesthesia_popup columns of table claims_anesthesia).

Pre-adjudication / benefit definition assignment

21. CLM-21 Pre-adjudication shall skip definition assignment for lines already rejected or on claims messaged "no coverage", assigning the system reject definition (key −1) (clmsproc/n_claim_adjudication, of_processclaimdef).
22. CLM-22 Dependent-care (DEPCARE) claims shall always receive the system dependent-care benefit definition; lines with procedure code CM2000 shall receive the system case-management-fees definition; MEDREIM, WDI and INELIGIBLE claims shall always have their benefit definition assigned manually (clmsproc/n_claim_adjudication, of_processclaimdef).
23. CLM-23 Definition assignment shall require the claim line's benefit plan to be in COMPLETE status and a benefit package to be assigned, otherwise messages 139 / 121 are raised (clmsproc/n_claim_adjudication, of_processclaimdef).
24. CLM-24 The system shall assign the first benefit definition, in package priority order, whose criteria all pass against the claim line: inpatient/outpatient indicator, procedure-group or procedure criterion, diagnosis-group or diagnosis criterion, procedure modifiers (modifier 1, then modifier 2), place of service, revenue code, and provider specialty; if all other criteria pass but the definition requires a specialty and the provider has none, message 164 "expected specialty" is raised (clmsproc/n_claim_adjudication, of_assigndef).
25. CLM-25 For UB92 inpatient room & board lines the system shall set the line through-date to from-date + units and raise an error when the resulting range falls outside the UB92 statement dates (message 156); for UB92 outpatient lines with 1 unit the through-date is set equal to the from-date (clmsproc/n_claim_adjudication, of_processclaimdef).
26. CLM-26 Room & board shall be identified by revenue code categories 10–17, 20 and 21 (first two digits) (clmsproc/n_claim_adjudication, of_isroomandboard).

Whole-claim (per-diem) pricing

27. CLM-27 A claim shall qualify for whole-claim pricing only when its repricing method is WHOLE, it is a UB92 repricing form, the member is on file, the provider is in network, code review did not change the claim, at least one line is inpatient room & board, not all lines are rejected, and all line networks (HCN) match the claim's network (clmsproc/n_claim_adjudication, of_iswholeclaimpriced).
28. CLM-28 Whole-claim pricing shall distribute per-diem amounts from the claim's reprice detail across each covered day, excluding the discharge day ("we do not pay discharge day"), and shall raise errors when units and room & board dates disagree, when multiple per-diem amounts exist for a day, or when a day has no per-diem amount (clmsproc/n_claim_adjudication, of_wholeclaimprice).
29. CLM-29 When the system determines a repricing sheet should not be a repricing claim (wrong network, unknown member, out-of-network provider, or code-review change), closing message 104 shall convert the claim to the equivalent standard form type (clmshare/n_cst_claims, of_closemessage case 104; claims/w_convert_to_reprice_form).

Accident processing

30. CLM-30 During pre-adjudication the system shall attach the claim to an existing accident record when the claim's diagnoses match the accident's diagnoses within 90 days of the accident; matches beyond 90 days, or accident-group diagnoses (ACC\INC diagnosis group) without a matching record, shall raise the "potential accident" message 191 (unless previously dismissed by a user) (clmsproc/n_claim_adjudication, of_accidentchecking, of_processclaimdef).
31. CLM-31 During adjudication, a claim attached to an accident record shall follow the record's action code: DENY raises message 193 for manual rejection, HOLD raises message 192, and PROCESS (or no record) closes both messages; user-closed accident messages are honored (clmsproc/n_claim_adjudication, of_adjudicateclaims; action codes HOLD/DENY/PROCESS in claims/d_accident_edit).

Adjudication core

32. CLM-32 Adjudication shall reject processing when the subscriber/patient pair does not exist in the family enrollment table (message 209) (clmsproc/n_claim_adjudication, of_adjudicateclaims).
33. CLM-33 Before applying rules, adjudication shall delete and rebuild all claim-line rules and claim-line accumulators for the locked claims, backing amounts out of member accumulators (clmsproc/n_claim_adjudication, of_adjudicateclaims, of_deletelineaccums).
34. CLM-34 Lines that are rejected, flagged as duplicates, or on a no-coverage claim shall have all computed amounts set to zero; duplicates receive system reason −2 and no-coverage lines system reason −1; any other rejected line must carry an examiner-supplied reject reason (message 180 otherwise) (clmsproc/n_claim_adjudication, of_adjudicateclaims).
35. CLM-35 End-stage renal disease claims shall require a Medicare COB record; ESRD claims without one raise message 210 (clmsproc/n_claim_adjudication, of_adjudicateclaims, DataWindow d_adjd_esrd_without_cob).
36. CLM-36 The system shall warn when a member approaches the plan's lifetime maximum, raising one-time member-level messages at 50% (201), 75% (202), 95% (203) and at/over 100% (204) of LIFETIME_MAX_AMT, computed from lifetime paid amounts plus lifetime credits (clmsproc/n_claim_adjudication, of_adjudicateclaims).
37. CLM-37 Rules shall be applied in package rule order, adjusted by each rule's "Applies After" dependency; an unresolvable (circular) ordering raises message 231 and stops adjudication of the line (clmsproc/n_claim_adjudication, of_applypackage, of_reorderrules).
38. CLM-38 Paid-limit (PAID) rules shall additionally be pre-tested before all other rules (PAID$TEST copies) so a limit already satisfied before this claim rejects the line up front (clmsproc/n_claim_adjudication, of_insertpaidtestrules, of_applyrule case PAID$TEST).
39. CLM-39 A rule shall be skipped unless the claimant's relationship matches the rule's subscriber/spouse/dependent flags; the patient's relationship is taken from the most recent RELATIONS member category value, with Spouse, Common Law and Ex-Spouse treated as spouse (clmsproc/n_claim_adjudication, of_applypackage).
40. CLM-40 A rule shall be skipped when its PCP, authorization, pre-certification, pre/post-admission, or referral indicator contradicts the claim's utilization-management case data (um_cases per claim line, plus pre-cert/referral stub tables) (clmsproc/n_claim_adjudication, of_applypackage).
41. CLM-41 A rule shall be skipped when the patient's age at date of service is outside the rule's minimum/maximum age (period types YEAR/MONTH/WEEK/DAY; age computed from birthdate minus one day), or when the current payable amount is outside the rule's min/max consider amounts, or when the rule's accident indicator contradicts the claim's accident linkage, or when the claim line's benefit definition is not in the rule's definition list, or when the rule's contingency-definition requirement is not met within the contingency period (clmsproc/n_claim_adjudication, of_applypackage).
42. CLM-42 Rule quantities shall be derived per the rule's quantity type: DATES/DAYS = days in the line's service period (inclusive); RBDAYS = days excluding the last (discharge) day; otherwise the line's units — optionally divided by the rule's quantity ratio; when the per-unit flag is N and the rule is not per-day, quantity is treated as 1 (clmsproc/n_claim_adjudication, of_applyrule).
43. CLM-43 The amount a rule may still retain shall be limited by the lesser of the individual and family maxima remaining on the member's accumulators for the rule's accumulator and period (accumulate by RETAINED, CONSIDERED−RETAINED, or QTY per the rule's accumulator type), and by a maximum count of family members who have individually satisfied the rule; for coinsurance (COI) rules the maximum is scaled by the retain percentage so COI behaves like out-of-pocket (clmsproc/n_claim_adjudication, of_lefttosatisfy, of_rulemax, of_satisfiedcount).
44. CLM-44 Rule-type computations shall be:
    • EXCL — retain the entire payable amount and stop processing rules;
    • 100PCT — retain nothing, record the amount/quantity as "considered at 100%" so later DED/COI/OOP rules exclude it;
    • COPAY — retain Min(consider_amt, Min(retain_value × qty, left_to_satisfy)) (per-quantity when quantity-accumulated);
    • DED — retain Max(Min(left_to_satisfy, consider_amt), 0) after removing 100%-considered amounts;
    • COI / OOP — retain Min(left_to_satisfy, consider_amt × retain% / 100) (retain% capped at 100), optionally feeding the remainder into the 100%-considered bucket when the rule's pct100_consider_ind = 'Y';
    • CLAIMED / PAID — retain the amount (or quantity, prorated) exceeding the remaining limit; when already satisfied retain the entire considered amount;
    • HOLD — set the line to HOLD, retain the full payable, and raise message 124 carrying the rule and reason; a user response ACCEPT releases the amount, DENY retains it with the chosen reason (clmsproc/n_claim_adjudication, of_applyrule).
45. CLM-45 The HOLD\MULTSRG (multiple-surgery) hold rule shall be applied only when the claim has more than one line (clmsproc/n_claim_adjudication, of_applyrule).
46. CLM-46 Per-day rules (PERDAY/PERDAYDR, except copays) shall not re-apply to days already counted for the member; when every day was already applied the line pays normally if the accumulator is unmet and is fully retained if it is met (clmsproc/n_claim_adjudication, of_applyrule, of_perday).
47. CLM-47 Rules with minimum/maximum unit bounds shall prorate the considered amount to the units inside the bounds and shall still accumulate even when nothing is considered (clmsproc/n_claim_adjudication, of_applyrule).
48. CLM-48 After rules are applied the system shall compute the claim-line waterfall: considered = allowed − exclusions − claimed-limit; then successively subtract copay (→ allowed-after-copay), deductible (→ allowed-after-deductible), coinsurance/OOP (→ allowed-after-coinsurance) and paid-limit retention (→ benefit amount) (clmsproc/n_claim_adjudication, of_claimlinesubtotals).
49. CLM-49 Every rule application with a non-null retained amount shall be recorded as a claim-line-rule row (rule, rule type, reason, retained amount/quantity) and shall update the member accumulator for the rule's accumulator key and computed period, creating the accumulator row if absent, adding considered amount/quantity only once per claim line per accumulator, and maintaining separate carryover buckets when the claim date falls in the rule's carryover window (carryover percentage clamped to 0–100%) (clmsproc/n_claim_adjudication, of_claimlinerule, of_updateaccumulators).
50. CLM-50 Rules with accident period types shall accumulate from the accident date, and lifetime accumulators are stored with a from-date of 1950-01-01 and open through-date (clmsproc/n_claim_adjudication, of_updateaccumulators).

Coordination of benefits

51. CLM-51 COB shall be evaluated once per claim line — immediately before the first paid-limit rule, or after all rules — and only when the line's plan has a COB method (clmsproc/n_claim_adjudication, of_applypackage, of_applycob).
52. CLM-52 When primary-carrier EOB detail is attached to the line and the member has an active COB record for the claim's coverage type, the payable amount shall be adjusted by COB method:
    • NORMAL: payable = Min(payable, Max(claimed − (cob_paid + Max(cob_writeoff, claimed − allowed)), 0));
    • CARVEOUT: payable = payable − cob_paid (floor 0);
    • REDUCECLM: the claimed amount was already reduced by the COB amount, so the function returns the sentinel −100 — its "COB not applicable to this claim line" value — rather than a payable amount; callers must treat −100 as no COB adjustment, not as a negative payable;
    • PAYBALANCE: payable = payable − cob_paid (no floor); and any COB reduction shall be recorded as a claim-line rule under the system COB rule (clmsproc/n_claim_adjudication, of_applycob).
53. CLM-53 EOB detail shall reconcile with the claim line: submitted amount must equal the line's claimed amount (message 185) and a non-zero allowed amount must equal submitted − write-off (message 186) (clmsproc/n_claim_adjudication, of_applycob).
54. CLM-54 The system shall message mismatches between EOB and enrollment COB data: EOB attached but no COB record (141); COB record without EOB when another internally administered plan is primary (143) or an external plan is primary (142) — except Medicare-primary drug claims, which process without an EOB (clmsproc/n_claim_adjudication, of_applycob).

Internal case-management services

55. CLM-55 For benefit definitions designated as CM-service definitions (therapy/DME), adjudication shall match the line to the member's open internal case-management service (by benefit definition, timeframe, and where needed procedure/diagnosis codes), raising message 225 when multiple services match, 226 when none match but similar services exist, and 227 when the claim would exceed the service's authorized units or dollars; matched usage updates the UM rule's units-used (unit-based) or soft-savings (dollar-based) (clmsproc/n_claim_adjudication, of_adjudicateclaims).
56. CLM-56 A user closing a CM-service message with response DENY shall cause the payable amount to be retained under the internal-CM rule (rule key 18443) with the user's chosen reason; response NOTSERVICE bypasses CM processing; response ACCEPT allows normal payment (clmsproc/n_claim_adjudication, of_adjudicateclaims).

Duplicates, audit, letters, EOB

57. CLM-57 Closing the duplicate message (102) shall present the candidate duplicate claims for side-by-side review; the examiner may mark the line "Not A Duplicate" (clearing the duplicate list) or retain an updated list (clmshare/n_cst_claims, of_closemessage case 102; claims/w_claim_message_duplicate; claims/u_duplicate_claim).
58. CLM-58 Audit selection shall be configurable by examiner (audit percentage, dollar limit, assigned weekday), by group (dollar limit, coverage type, all-claims flag), by member, by provider, by procedure code and by diagnosis code, each with effective date ranges (claims/w_audit_examiners_selection, w_audit_groups_selection, w_audit_members_selection, w_audit_providers_selection, w_audit_procedure_codes, w_audit_diag_codes_selection; tables audit_*).
59. CLM-59 Releasing a claim from audit (closing message 151/171) shall require every other error message closed, then either advance the claim to Funding (RFF, or REXOUT when the claim is electronically paid) with an immediate save/commit/unlock, or return it to Corrections (claims/w_setstatusfromaudit; clmshare/n_cst_claims, of_closemessage case 151).
60. CLM-60 Claim letters shall be issued from the claim (message 212/157 per letter), may be attached to or detached from related claims, and shall be archived when their message is closed or the claim moves to a sub-status (claims/w_claims_letters pfc_update; clmshare/n_cst_claims of_closemessage cases 157/212; clmshare/n_cst_return_claim_to_corrections).
61. CLM-61 The system shall print an EOB for a claim on demand (clmprint/w_claim_print_eob with n_check_copy), and shall allow unattached primary-carrier EOBs for a member (by SSN) to be attached to a claim (claims/w_eob_attach, w_eob_selection, w_eob_edit, w_eob_edit_claim_lines).

Outbound EDI & external adjustments

62. CLM-62 A user shall be able to mark a claim for outbound EDI to a chosen trading partner exactly once; the claim is inserted into the outbound EDI transactions table and message 223 records the selection (claims/w_claim_editor ue_outbound_edi; claims/w_claims_partners_select).
63. CLM-63 The outbound EDI processor shall stage claim, subscriber, patient, provider, line and form-specific data into the outbound_edi_* staging tables, write one fixed-width file per network/claim-form-type per day to the configured output directory (codes APPPATHS/OUTEDI), and purge staging rows once the file is created (clmutils/u_edi_outbound_edi; clmutils/w_edi_outbound_edi_processor).
64. CLM-64 External adjustment requests shall be tracked with statuses NEW / IN PROCESS / COMPLETED, with reports of outstanding adjustments and outstanding refunds (claims/w_ext_adjustment, claims/d_ext_adjustments; clmrpt/w_clmrpt_outstanding_adjustments, w_clmrpt_outstanding_refunds).

Manual adjudication support

65. CLM-65 The Adjudication tab shall show, per selected claim line, the benefit rules applied (with retained amounts, editable exclude flag), the manually entered pricing rules, adjudicated amounts, and rule totals; manually added claim-line rules receive new system keys at save (clmentry/u_adjudication; DataWindows clmshare/d_claim_line_rules_master, d_claim_line_pricing_rules_master).
66. CLM-66 Enrollment-confirmation gate: the annual-enrollment message (146) shall not be closable until enrollment records a CONFIRMED member category value covering the claim's earliest service date, or every claim line is rejected (clmshare/n_cst_claims, of_closemessage case 146).
67. CLM-67 Vision procedures on a medical form (message 211) shall require the examiner to choose processing under medical coverage (recorded as Response:MEDICAL) or to void and re-enter the claim on a vision form (clmshare/n_cst_claims, of_closemessage case 211).

Requirements recovered from the user guide (background-process behavior)

The requirements below describe behavior of the background batch application (SFPIBACK) that is outside the eight recovered claims libraries; the source is the official user guide (requirements/operations vintage 1998–2010), not code. They should be re-verified against the recovered batch binary or the database before migration.

68. CLM-68 (User Guide ch. 11) Duplicate check (RFDC stage): a claim line shall be flagged an exact duplicate when, against any single existing line: patient sys_key matches; provider sys_key matches (not used for WDI, HCR, Drug, DepCare); place of service matches (same exclusions); line from/through dates match; billed amount matches (not used for WDI, HCR, DepCare); procedure code or revenue code matches (form-type exclusions apply); LT/RT modifiers match when present; claim form type matches (Vision, MedReim, Drug, DepCare, Ineligible only); benefit definition matches (HCR only); tooth and surface number match (Dental only). Rejected lines are ignored; only claims at Ready-For-Pricing status or later are compared. Exact duplicates on HCR, MedReim, WDI, Drug and DepCare claims are downgraded to possible duplicates.
69. CLM-69 (User Guide ch. 11) A claim line shall be flagged a possible duplicate when the patient matches, service dates overlap, procedure/revenue codes match (or the procedure code does not begin with 7 or 8), LT/RT modifier logic passes, and either the vendor or the billed amount matches; DepCare, WDI and Drug claims are not checked for possible duplicates. Possible duplicates raise a message for examiner disposition; the examiner must mark each line duplicate or not-a-duplicate before the claim can proceed.
70. CLM-70 (User Guide ch. 11 & 14) Duplicate lines whose original claim is unpaid, or was paid within the previous 21 days, shall be voided (all lines voided voids the whole claim); other duplicate lines are rejected with the duplicate reason and continue forward. EOBs shall be produced for rejected duplicate lines only when the original line was paid more than 21 days before the current date, and never for rejected responses to repricing requests.
71. CLM-71 (User Guide ch. 10) The Claims Entry background process shall validate that service dates fall between 1980-01-01 and the claim received date (DepCare/WDI: only the 1980 floor), that line from dates precede through dates, that line claimed amounts balance to the claim total (HCFA, HCFA reprice, UB92, UB92 reprice, Dental), shall replace procedure code G0001 with 36415 before code review, and shall expand the keyed word SAME by copying subscriber name/address to patient or vice versa.
72. CLM-72 (User Guide ch. 10) Member identification shall cascade: subscriber by member number, then SSN, then last/first name (narrowed by group, then city/state, then address line 1); patient within the subscriber's family by first letter of first name plus birth date; failing that, patient searched across the database and the subscriber inferred from the family. Each claim shall carry an informational message recording the method used, and unidentified claims (no subscriber, patient or group) shall be set to unidentified status.
73. CLM-73 (User Guide ch. 10) Provider identification shall cascade from federal TIN, then physician name, then billing name (person, then company), refined by billing address and then by the member's HCN in package-priority order; when a TIN's EIN-vs-SSN type is not indicated it shall be derived from the state-to-EIN-prefix table, and ambiguity raises an error for the Provider department.
74. CLM-74 (User Guide ch. 10 & 11) Payee assignment: signature "on file" pays the provider; "pay subscriber" or a prepaid balance pays the subscriber; signature on file with a non-zero amount-paid marks a possible split resolved during adjudication (amount due to provider, remainder to subscriber, when the prior payment was not COB). WDI, medical-reimbursement and dependent-care claims always pay the subscriber; UB92, dental, vision, WDI and reimbursement forms are never split. Claims payable to the subscriber above the guide threshold are forced through manual adjudication (guide states both $500 and $5,000 in different sections — SME confirmation needed).
75. CLM-75 (User Guide ch. 10) Inpatient/outpatient assignment: UB92 lines are inpatient when any line's revenue code is room & board, or per the bill-type (box 4) digit matrix for interim bills; observation revenue codes 760/761/762/769 totaling over 24 hours convert the claim to inpatient and hold it for examiner review; HCFA lines follow the place-of-service table; all other forms are outpatient. Derived UB92 place of service: inpatient = 21; outpatient = 24 (rev 36x/49x/75x/481 with ambulatory-surgery specialty), 23 (rev 45x), else 22.
76. CLM-76 (User Guide ch. 10 & 11) Code review (RFCR stage) shall process only HCFA, generic-medical (non-facility), HCFA/generic repricing and EDI professional claims, at most 100 lines per claim; it is skipped when the HCN disallows it, when Medicare is primary for the patient, or for excluded client groups. Outcomes: claim changed → back to RFCP for re-edit; unchanged → RFPA; unprocessable → stays RFCR with an error. A changed repricing sheet must be returned to the HCN for repricing (except lines combined with 36415). Before/after line images are retained for examiner review.
77. CLM-77 (User Guide ch. 16) Audit selection defaults and triggers: every claim above the master-group dollar limit (default $5,000; zero = audit everything) is audited even if clean; examiner-based selection uses audit %, dollar limit (default $1,000) and assigned weekday, with an examiner absent from the table audited at 100% (new examiners' work is fully drawn for their first three months); plus member, provider, procedure-code and diagnosis-code triggers and a random-sample floor (guide cites 5%/15% in different sections). Audit messages are evaluated in a fixed order (UM procedure/diag triggers, funding-payable mismatch, negative dollars, provider holds, auto-flex, rejects/exclusions, UB payable-to-member, medical over $5,000, dental over $1,000, medical over $500 payable to subscriber or split, patient holds, adjustments, no-eligibility rejects, foreign claims, random sample). Zero-pay claims are not audited when all lines went to deductible, all lines are duplicates, or lines rejected for no eligibility.
78. CLM-78 (User Guide ch. 11) Claims held longer than 60 days shall be automatically rejected with a "required response never received" message, with a follow-up notification letter generated 30 days before rejection and a close letter at rejection, both templated from the message associated with the hold. (Stated as a requirement in the guide; not evidenced in the recovered code — SME confirmation needed.)
79. CLM-79 (User Guide ch. 14) Claims output shall produce, per check run: EOBs (member payee), RAs (vendor payee, one per provider per group per run), EOB Copies ("Employee Copy", per vendor payment, never with a check), and optional Employer Copies; checks print on check stock with the check on the top portion, worksheets (zero-pay or group-disbursed) on plain paper; registers, EOBs and RAs shall be archived non-editable (print image as BLOB) searchable by register date, check number or worksheet number, with reprint by check run or single payment; QMCSO dependents with an alternate address are paid at that address in the dependent's name with EOBs to both subscriber and dependent; rejected claims still flow to Funding and appear on the register as zero-dollar lines with an EOB/RA; interim claims produce a zero-paid EOB carrying "Interim claim received, waiting for final bill".
80. CLM-80 (User Guide ch. 10) Eligibility verification shall run per claim line, once a coverage type is assigned and both parties are identified, and shall resolve the subscriber line by line rather than once per claim:
    • Where the claim header identifies no single subscriber, the patient is searched across all families; failing that the claim is held with a "neither subscriber nor patient identified" message.
    • A line whose patient has no subscriber for its service dates is tested for COBRA: an open letter-QB naming the patient, with null or covering dates, marks a potential subscriber — the claim is held, unprocessed, until that person enrolls or declines.
    • When lines disagree on subscriber, each inconsistent line is messaged with the count and sys_key of every alternate subscriber found, and processing continues.
    • Coverage outcomes per line: unpaid COBRA coverage raises an error; a latest coverage terminated with reason Re-Enroll (or an eligibility period terminated for re-enrollment) raises an Enrollment message that the background process clears automatically when the data arrives, and that rejects the line if a user closes it instead; any other absence of coverage or eligibility rejects the line silently with reject reason no coverage and bypasses code review; a line falling partially inside an eligibility period is messaged to an examiner on the same auto-clear/reject-on-close terms.
    • A subscriber whose address line 1 is literally INITIAL ENROLLMENT stops the whole claim with an Enrollment message; closing it manually sets the claim to RETURN.
    • When no detail line finds group coverage, an examiner is messaged proposing the return table; and when the master group is terminated as of the claim's received date, the claim is sent to RETURN status outright.
81. CLM-81 (User Guide ch. 10) Run-out processing is configured per group coverage (and must be set up separately on every coverage of every division). Where an election is found for the patient but the group coverage's expiration date precedes the claim's received date, the claim shall be processed only when the received date falls on or before that coverage's run-out date; otherwise the claim shall be sent to RETURN status with a message.

Key formulas quoted from source

Copay / deductible / coinsurance retention (clmsproc/n_claim_adjudication, of_applyrule):

case 'COPAY'
    ld_retain_amt = Min(ld_consider_amt, Min( ld_rule_retain * ld_qty, ld_left_to_satisfy))
case 'DED'
    ld_retain_amt = Max(Min(ld_left_to_satisfy, ld_consider_amt), 0)
case 'COI' / 'OOP'   // ld_rule_retain capped at 100
    ld_retain_amt = Min(ld_left_to_satisfy, ld_consider_amt * (ld_rule_retain / 100))
case 'CLAIMED' / 'PAID'
    if lb_satisfied then                       // limit already met before this line
        ld_retain_amt = ld_consider_amt        // retain everything
    elseif ld_consider_amt > ld_left_to_satisfy then
        ld_retain_amt = ld_consider_amt - ld_left_to_satisfy
    else
        ld_retain_amt = 0

Claim-line subtotal waterfall (clmsproc/n_claim_adjudication, of_claimlinesubtotals):

ld_subtotal_amt = Dec(ads_clm_line.Object.allowed_amt[1])
ld_subtotal_amt = ld_subtotal_amt - ld_excl_total
ld_subtotal_amt = ld_subtotal_amt - ld_clmd_limit_total
ads_clm_line.Object.considered_amt[1] = ld_subtotal_amt
ld_subtotal_amt = ld_subtotal_amt - ld_copay_total
ads_clm_line.Object.allowed_after_copay_amt[1] = ld_subtotal_amt
ld_subtotal_amt = ld_subtotal_amt - ld_ded_total
ads_clm_line.Object.allowed_after_ded_amt[1] = ld_subtotal_amt
ld_subtotal_amt = ld_subtotal_amt - ld_coi_total
ads_clm_line.Object.allowed_after_coi_amt[1] = ld_subtotal_amt
ld_subtotal_amt = ld_subtotal_amt - ld_paid_limit_total
ads_clm_line.Object.benefit_amt[1] = ld_subtotal_amt

COB NORMAL method (clmsproc/n_claim_adjudication, of_applycob):

ld_payable_amt = Min(ld_payable_amt, Max((ld_claimed_amt - (ld_cob_amt
    + Max(ld_cob_write_off_amt,
          (Dec(ads_clm_line.Object.claimed_amt[1]) - Dec(ads_clm_line.Object.allowed_amt[1]))))), 0))

Status advance on clean claims (clmsproc/n_claim_adjudication):

// of_update_claim_status: no open messages, not VOID/RETURN
adw_claims.Object.claim_status_cd[ll_cur_claim] = "RFDC"
// of_update_adjudication_status: no open messages and status = RFA
adw_claims.Object.claim_status_cd[ll_cur_claim] = "RFAL"

Data touched (main tables)

CRUD summarized from _re/analysis/schema.json for the eight claims libraries.

Area	Tables (CRUD)
Claim core	claims (CRUD), claim_entries (CRUD), claim_lines (CRUD), claim_entry_diag_codes (CRUD), claim_line_diag_codes (R; deleted via embedded SQL on line delete), claims_xref (R)
Form-specific detail	claims_hcfa_info, claims_ub92_info, claim_ub92_conditions/occurrences/procedures/values, claims_ub92_itemized, claims_dental_info, claim_missing_teeth, claims_vision_info, claims_reimb_info, claims_wdi_info, claim_wdi_lines, claims_sso_info/diagnosis/procedure, claims_anesthesia, claim_other_ins_infos (all CRUD)
Adjudication results	claim_line_rules (CRUD), claim_line_accums (CRUD), claim_line_pricing_rules (CRUD), claim_line_payments (CRUD), member_accums (CRUD), member_accum_credits (CRUD)
Benefit configuration (read)	benefit_plans, benefit_pkgs, pkg_rules, benefit_rules (CRUD via rule utils), benefit_defs, benefit_def_diags/procs, rule_defs, rule_contingency_defs, pkg_rule_dependencies/fulfillments/requirements, level_scheds, carryover_rules, rounding_rules, group_periods (CRUD)
Messages & status	claim_messages (CRUD), global_messages (R), claim_statuses (R), claim_statuses_history (R), claim_status_order (R)
COB / EOB	coord_of_bens (CRUD), claim_eob_infos (CDU), claim_eob_info_details (CRUD)
Accidents	accidents, accident_members, accident_diagnoses, accident_claims (all CRUD)
Audit config	audit_examiners, audit_groups, audit_members, audit_providers, audit_procedure_codes, audit_diagnosis_codes (all create/update/delete, most read)
Repricing / networks	claims_reprice_info (CRUD), claims_reprice_detail (CRUD), edi_in_repricing (CRU), health_care_networks (R), moon_negotiations (R)
Payment / funding handoff	fund_register (CRUD), fundtrans (R), bank_acct_info (R), ext_adjust (CRUD), ext_output_transactions (R)
Letters	claim_letters_hist (CRUD), claim_letters_hist_claims (CRUD), claim_letters_data (D), letter_headers (R), report_archive (R)
Outbound EDI	outbound_edi_transactions (CRUD), outbound_edi_trading_partners (R), 11 outbound_edi_*_table staging tables (CRUD)
UM / internal CM	um_cases, um_services, um_rules (CRUD), um_case_mgt_claims (CRUD), um_cm_serv_excl_proc_cd (R), claim_precert_stub / claim_referral_stub (CRUD; labeled temporary)
Enrollment/provider (read)	members, family, member_cat_val, member_eligibilities, member_pcps, groups, providers, provider_addresses, provider_tins, vendors, specialties, procedure_codes/groups, diagnosis_codes/groups
Legacy conversion	wang_claims, wang_claim_lines, wang_claim_line_rules, wang_acm, wang_rej_map, wang_rule_map, wang_group_rule_map (CRUD; see Migration notes)

Reports produced (clmrpt)

Report window	Business purpose
w_clmrpt_accum_rpt (Member Accumulator Listing)	Accumulators for a group's members, incl. medical/dental deductible variants and pending (non-paid) claims affecting accums (d_clmrpt_accum_rpt*, d_clmrpt_accum_pending)
w_clmrpt_member_accum_search	Member/family accumulator search — claims affecting accumulators (d_clmrpt_member_accum_search_results)
w_rpt_group_selected_accums	Accumulators by member for selected accumulators/reasons
w_rpt_member_accum_rulemax	Member accumulators by benefit rule with maxima (d_rpt_member_accum_byrule)
w_rpt_group_claim_bendefs	Detailed claims listing by benefit definition
w_rpt_group_claim_benrules	Detailed claims listing by benefit rule type
w_clmrpt_status_count	Claims count per pipeline status (d_clmrpt_status_count)
w_clm_message_status_summary	Message/status summary per group
w_clmrpt_open_messages	All claims with open messages
w_clmrpt_claims_older_than_90_days	Claims older than 90 days for a group / parent group
w_clm_claimed_amt_morethan	Claims with claimed amount above a threshold
w_claimrpt_large_claim_report	Large-claim report
w_clmrpt_no_sub_or_pat	Claims lacking subscriber and/or patient assignment
w_no_group_id_fix	Claims with no group id assigned
w_clmrpt_outbound_aging_tv, w_clmrpt_outbound_edi_older_than_10_days	Outbound-EDI aging; claims sent to partners not returned within 10 days
w_clmrpt_outstanding_adjustments, w_clmrpt_outstanding_refunds	Outstanding external adjustments / refunds
w_cigna_p4p	Cigna pay-for-performance extract (d_clmrpt_cigna_p4p_out, cigna_report_groups)
w_ppaca_letters	PPACA letters
w_nobs_group_rpt	Group report (NOBS)
Lifetime/credits datastores	d_clmrpt_lifetime_rpt (lifetime amounts per member), d_clmrpt_credits_rpt

clmprint additionally provides print/reprint layouts for every claim form (d_claim_print_*), EOB printing (w_claim_print_eob, n_claim_print, n_check_copy) and check-payment views (d_check_payments, d_check_payments_backed_out, d_checkrun_claim_lines).

Integration points

• Outbound EDI staging — outbound_edi_transactions plus 11 outbound_edi_* staging tables flattened to fixed-width files per trading partner/HCN and claim-form type; directory from codes (APPPATHS/OUTEDI) (clmutils/u_edi_outbound_edi). Claims marked from the editor (claims/w_claim_editor ue_outbound_edi); returns monitored by aging reports.
• HCN repricing — repricing claim forms carry hcn_sys_key (network chosen via claims/w_claims_hcn_list), reprice header/detail in claims_reprice_info/claims_reprice_detail, inbound repriced data in edi_in_repricing; whole-claim per-diem pricing consumes reprice detail (CLM-27/28).
• Aetna electronic claims — claims with id prefix EAET show the transmit date from ext_output_transactions; electronically paid claims leave audit as REXOUT (clmentry/u_payment; clmshare/n_cst_claims case 151).
• Funding module — fund_register rows (worksheet/expected/paid amounts, register status, backout) written at save and consumed by check runs; funding-status rules gate editing (CLM-8, CLM-14).
• Utilization management / internal CM — um_cases, um_services, um_rules, um_case_mgt_claims; adjudication decrements/increments service authorizations (CLM-55/56); claims can be attached to internal CM cases (claims/w_add_claim_to_internal_cm).
• Moon negotiations — negotiation checking moved out of adjudication to the Moon background process (comment in clmsproc/n_claim_adjudication, of_adjudicateclaims).
• Caremark (pharmacy) — non-claim record file creation (clmutils/w_caremark_non_claim_record, caremark_edi_table).
• Letters/print archive — letters archived through the reprint subsystem (n_cst_reprint_print_reports.of_ArchiveItem('CLMLETTERS', …)).

Migration notes

• Data-driven pipeline: status order, display names and screen families live in claim_status_order; do not hard-code the pipeline — except the nine background stages listed in clmutils/w_bkgd_monitor, which a migrated orchestrator must reproduce.
• The adjudication engine is the crown jewel: clmsproc/n_claim_adjudication implements definition assignment, rule ordering/filters, nine rule types, accumulator maintenance with carryover, COB and CM-service integration. The formulas in CLM-42..CLM-54 should be treated as the executable specification and covered by regression tests before migration.
• Message-driven workflow: every edit/exception is a claim_messages row with message number, field_name (often Row:n;DBName:col), system_comment key-value text (e.g. DupClaims:, RuleKey:, Response:), and control codes (DELONRESET, DONOTCLOSE, SC; = system-closable only). Closing a message can trigger status transitions and saves (cases 151/167). A migration must preserve these semantics or redesign the exception workflow wholesale.
• User-closed message memory: adjudication honors messages previously closed by a human (close user id not sfpiback) — e.g. no-coverage, accident deny/hold, potential accident. Idempotent re-adjudication depends on this.
• Known technical debt flagged in source: precertification and referral use "temporary stub tables" (claim_precert_stub, claim_referral_stub); accumulate-by-tooth is a workaround via pseudo benefit definition −110; COI is "kind of a mess" (treated as OOP); several TBC! markers (days-of-week rule check unimplemented, possible rounding error in COI 100%-consider back-computation).
• Magic keys: system rule/definition keys are negative or hard-coded — COB rule −100, DEPCARE definition −101, write-off rule −102, case-management fees −111, whole-claim reason −201, reject definition −1, no-coverage reason −1 (a different table from the reject definition that shares the literal), duplicate reason −2, internal-CM retain rule 18443 (a bare literal, not a named constant), accumulate-by-tooth pseudo definition −110. These must be carried or remapped. Two cautions: the write-off rule −102 is declared but its only use in n_claim_adjudication is commented out, so verify whether write-offs are still applied anywhere before porting it; and −100 is overloaded — it is both the COB rule key and of_applycob's "COB not applicable" sentinel return (CLM-52).
• Wang legacy conversion: of_wang_* functions and wang_* tables are one-time claim-history conversion from a prior (Wang) system; likely dead code for a future migration but the converted history feeds accumulators.
• Return-to-corrections is the transactional heart of edit-after-the-fact behavior (CLM-14); any migrated design needs an equivalent compensating-transaction routine.
• Oracle-specific SQL throughout (sequences logical_lock_seq, claim_seq, all_purpose_seq; (+) outer joins; DECODE, NVL, FROM dual).

Behavior that lives outside the PowerBuilder libraries (User Guide)

• Database-implemented functionality the guide attributes to triggers rather than PowerBuilder code: (a) on reaching Ready-For-Funding, "a database trigger will make an entry into the Register table for the new benefit payment", with the register process later stamping the Newly-Reported date (User Guide ch. 11); (b) "The system (via a trigger) will calculate balance due as the difference between the total charge and the amount paid", with the background process raising an error only when a keyed balance-due disagrees (User Guide ch. 10); (c) an accident-date change is expected to cascade into accident-period accumulator from-dates ("a trigger would be the best answer"), with the reconciliation SQL quoted in the guide (User Guide ch. 11). These must be recovered from the Oracle DDL (pending task) — they will not appear in any PBL.
• Provider auto-assignment memory: selecting a provider for a claim writes a link row keyed on the claim's billing-provider TIN/name/address + performing-provider name + facility name (CLAIM_ENTRIES columns are enumerated in the guide), so later claims with identical provider data are assigned automatically; links are replaced on re-selection and deleted when the provider is inactivated (User Guide ch. 10). Reproduce or consciously drop in a migration.
• Automatic provider/contract generation from reprice sheets: since 06/2003 provider contracts (and since 07/2004, providers themselves, switch-controlled per HCN) are created automatically from clean reprice sheets, effective the first of the month of the sheet's overall from-date (User Guide ch. 10).

Guide-vs-code discrepancies for SME confirmation

The user guide is a mixed requirements/operations document (file dates 1996–2010); the code is authoritative for current behavior. Items where they diverge or the guide contradicts itself:

• Duplicate handling: the code rejects duplicate lines with system reason −2 and drives disposition through message 102 (CLM-34, CLM-57); the guide's final (12/6/99) rule voids duplicates of claims unpaid or paid within 21 days. Which behavior shipped last should be confirmed against the batch code.
• Manual-adjudication threshold: guide ch. 10 says claims payable to subscriber over $5,000 are forced through manual adjudication; guide ch. 11 says over $500 (and the ch. 16 audit-trigger list has "Medical claim $ > 500 … payable to subscriber or SPLIT"). Not evidenced in the recovered code.
• Claim-number timing: one guide bullet states "Claim numbers are not assigned until after adjudication" (User Guide ch. 11) — contradicted by both the code (CLM-1/2: id generated at first save) and guide ch. 10; treat as stale requirements text.
• Outsourced-claim prefix: guide ch. 10 says outsource-keypunch claim numbers "always begin with the letter S" in one section but defines O = Outsourced in the prefix list; the outsourcing arrangement (Sage) is also annotated "we no longer use sage" in later margin notes.
• Audit re-selection: guide ch. 16 first states an audited claim is never audited again, then records that per Ayn Zellman 07/22/1999 "this is no longer true" — the later note governs.
• Return-claims purge: the monthly physical deletion of claims marked for deletion (guide ch. 10) has no counterpart in the recovered libraries; find the job before migration.
• Guide-only features: pre-existing-condition checking (90-day/plan-period edit and pre_ex table), COB bank, stoploss accumulation, DRG groupers and automatic WDI payment generation are specified in the guide chapters but were not found in the eight claims libraries — either implemented in the background/other domains, or never delivered; classify before scoping migration.

Open questions

1. Where do stage transitions RFCP→RFCR→RFPA and RFDC→RFPR→RFA run? Largely resolved. The user guide confirms these run in separate background applications, not the interactive libraries: the Claims Entry background process is "run by the MIS department at least daily … usually continuously during the day"; it locks claims in batches, skips claims open in any window or on Hold, performs the RFCP edits (CLM-71..75) and advances clean claims to RFCR or directly to RFPA when code review does not apply (User Guide ch. 10). Code Review was a distinct program (HPR proprietary software, originally on an HP host; in early production a manually launched desktop utility with a Start button) that moves RFCR→RFPA, or back to RFCP when it changed the claim (User Guide ch. 10). The nightly Automated Adjudication cycle performs duplicate checking (RFDC), pricing, adjudication and payment allocation (User Guide ch. 11). This matches the SFPIBACK actor seen throughout the code; the batch binary/PBLs themselves are still unrecovered (see SFPIBACK recovery task).
2. Duplicate-detection algorithm: Resolved by the user guide — full exact-duplicate and possible-duplicate criteria plus disposition rules are now captured as CLM-68..CLM-70 (User Guide ch. 11). Residual risk: the guide text is vintage 1999–2000 (with dated change notes, e.g. "void duplicates paid less than 21 days ago — 12/6/99 KEM"); the shipped SQL should still be confirmed against the recovered batch code or database.
3. Message catalog: Partially resolved. The guide documents the message model: messages are Informational (auto-closed at creation), Error (open until resolved; the background process auto-closes them when the underlying condition is fixed) or User-Defined (closed manually), and each global_messages row carries an area column whose prefix routes correction work (EN = Enrollment, PV = Provider Maintenance, etc.); a per-message Help window carries response instructions (User Guide ch. 10). The numeric catalog (text/severity/control codes for messages 42–231) still needs to be pulled from the global_messages table.
4. Message 167 dual use: confirmed as a genuine collision in the source, cause still open. Message 167 is declared in clmsproc/n_claim_adjudication as il_whole_claim_error and logged on whole-claim-pricing failures, while clmshare/n_cst_claims (of_closemessage) treats closing 167 as the pre-adjudication release popup (w_setstatusfrompreadj → RFDC/RFCP). Both usages are live and sit in different libraries, so a whole-claim pricing failure and a pre-adjudication hold are indistinguishable by message number. The user guide never cites message numbers, so it neither confirms nor refutes. Pull message 167's text and control codes from global_messages to determine which meaning the catalog records — and treat this as a defect to resolve rather than a modelling choice to carry forward.
5. RETURN vs DELETE: Resolved as intentional design. The guide defines Return status as "a claim that needs to be returned to the entity that sent it"; requesting the cover letter marks the claim for deletion rather than deleting it, and "the system will physically delete all claims marked for deletion that are more than a month old" (User Guide ch. 10). The 04/2000 change (CLM-11) therefore implements the documented workflow. Discrepancy: the physical-purge job is not in the recovered libraries — presumably in the background application or a database job; locate before migration.
6. REXOUT lifecycle: set when releasing electronically-paid claims from audit; downstream handling (presumably in Funding/EDI-out) is outside this domain. The guide (vintage predates Aetna electronic payment) does not mention it — still open.
7. Accumulator error correction: Partially resolved. The guide states that all manual accumulator updates are issued as credits kept separately from the member accumulators (prior-carrier balances, offsets not attributable to system claims) and combined during processing — matching member_accum_credits (User Guide ch. 11). The drift-repair routines (of_getaccumerrors / of_correctaccumerrors / of_reaccum) remain undocumented operationally.
8. Pre-cert/referral stubs: whether real UM data superseded the stub tables (um_cases is retrieved and the stubs are still checked in of_applypackage) needs business confirmation. The guide describes the intended full UR model — Authorization / Admission-Notification–Pre-Certification / Referral switches per package rule with values Y (record required), N (record must be absent), blank (always run) (User Guide ch. 11) — consistent with the stubs being an interim bridge.