COBOLSTACK.COM
//SEAM    EXEC PGM=ANALYZE,PARM='ESTATE'

Every analyzer stops at the platform edge.
We assess the handoff itself.

The mainframe writes a file at end of cycle. Something moves it. A loader ingests it. Stored procedures unpack, validate, reconcile and post — code written in 2004 that has run ever since. That boundary is where migrations stall, and no single-platform tool's scope covers it.

//REPORT  DD DSN=WHAT.YOU.GET

One command over captured artifacts

Layout verification
Your copybooks (or IBM i DSPFFD catalogs) against the loader configuration actually deployed — not the copy in source control. Framing, type-class, boundary, scale and sign findings, severity-ranked. A byte-exact decode preview flags anything that violates packed-decimal rules instead of guessing.
Field-level lineage
Every interface field traced: copybook byte range → unpack call → staging column → posted column. Parse coverage is printed; anything outside the analyzed subset or with a data-dependent offset is listed UNRESOLVED — never silently guessed.
The batch-window graph
Scheduler definitions (CA-7/Control-M-style), JCL step graphs, transfer hops and the target's scheduler chains merged into one DAG. Handoff artifacts carry their record layouts; reconciliation and halt conditions are traced across platforms; a consumer that fires on the clock with no dependency on its input file is surfaced as the late-file risk it is.
The risk register
Findings mapped to a defect taxonomy with cited evidence: layout drift, control-figure rewrites (the "auto-correct" that edits a failed completeness proof into passing), window violations, dead code that looks alive.

Deliverables: a stranger-readable report (HTML + PDF), an interactive explorer (one self-contained file — works on an air-gapped network), machine-readable JSON, and the graph source. Inputs are sha256-pinned; two runs of the same inputs are byte-identical.

//FINDINGS DD DSN=SEVERITY.CLASSES

For the engineer: what a finding actually is

No black boxes. Every finding has a class, a severity with defined semantics, and the evidence that produced it:

SeverityMeaningExample
CRITICALbytes are misread as the wrong class — values will be garbage or the load abortsrecord framing 220 vs 240 (every record after the first shifts); COMP-3 bytes decoded as character; a control column written from trailer bytes by one proc and overwritten from measured data by another
MAJORvalues land but lie, or a structural risk standsscale mismatch (off by 10^n); a clock-fired consumer with no arrival dependency on its input file; a proc reachable from no scheduler entry or documented root
MINORinformation can be droppedsigned field read unsigned (negatives lost); digit capacity narrowed
INFObenign notes kept for completenessfield-name pairings; bytes the target deliberately skips

Honesty is mechanical, not editorial: parse coverage prints as a percentage of statements; an unpack whose offset comes from data (not a constant) lands in UNRESOLVED with its source line, never a guess; replay divergences that match no known cause report DIVERGENT-UNEXPLAINED. Lineage rows carry exact byte ranges (TR-CT-AMT bytes 97+7 → SEAM_CTL.TRL_CT_AMT via UNPACK_COMP3) so you can check any row against the copybook with a hex viewer — and we encourage you to.

//REPLAY  EXEC PGM=GOLDENRUN

Golden runs: proof, not diffing

Row counts prove the copy. Golden runs prove the system. We execute your batch — your programs, your job streams, masked data — to produce baseline outputs, then byte-compare any modernized target against them: posted state, control tables, reports. Divergences are explained with evidence, or reported DIVERGENT-UNEXPLAINED; a cause is never fabricated.

Target-agnostic by design. We verify anyone's migration — which makes every migration vendor a potential channel, not a competitor. Expected fixtures are captured by your staff on your systems under a written protocol; we never log on to your iron.

REPLAYBASELINE VS TARGETEQUIVALENT

The walkthrough we do live

Replay a cycle with the loader config a DBA is actually running: the load aborts, the analyzer explains exactly why — record framing 20 bytes short of the copybook of record, with the evidence — the config is regenerated, the cycle reruns, and equivalence to the expected baseline is proven to the byte. Red, explained, green, proven: about ninety seconds. That is the product.

Want your own people to own the boundary? CS300 — The Seam teaches exactly this, on the same estate.